using Capnp;
using Capnp.Rpc;
using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace CapnpGen
{
    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xd82dcd751f51b615UL)]
    public class AuthMessage : ICapnpSerializable
    {
        public const UInt64 typeId = 0xd82dcd751f51b615UL;
        public enum WHICH : ushort
        {
            Mechanisms = 0,
            Request = 1,
            Challenge = 2,
            Response = 3,
            Outcome = 4,
            Abort = 5,
            undefined = 65535
        }

        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            switch (reader.which)
            {
                case WHICH.Mechanisms:
                    Mechanisms = reader.Mechanisms;
                    break;
                case WHICH.Request:
                    Request = CapnpSerializable.Create<CapnpGen.Request>(reader.Request);
                    break;
                case WHICH.Challenge:
                    Challenge = reader.Challenge;
                    break;
                case WHICH.Response:
                    Response = reader.Response;
                    break;
                case WHICH.Outcome:
                    Outcome = CapnpSerializable.Create<CapnpGen.Outcome>(reader.Outcome);
                    break;
                case WHICH.Abort:
                    which = reader.which;
                    break;
            }

            applyDefaults();
        }

        private WHICH _which = WHICH.undefined;
        private object _content;
        public WHICH which
        {
            get => _which;
            set
            {
                if (value == _which)
                    return;
                _which = value;
                switch (value)
                {
                    case WHICH.Mechanisms:
                        _content = null;
                        break;
                    case WHICH.Request:
                        _content = null;
                        break;
                    case WHICH.Challenge:
                        _content = null;
                        break;
                    case WHICH.Response:
                        _content = null;
                        break;
                    case WHICH.Outcome:
                        _content = null;
                        break;
                    case WHICH.Abort:
                        break;
                }
            }
        }

        public void serialize(WRITER writer)
        {
            writer.which = which;
            switch (which)
            {
                case WHICH.Mechanisms:
                    writer.Mechanisms.Init(Mechanisms);
                    break;
                case WHICH.Request:
                    Request?.serialize(writer.Request);
                    break;
                case WHICH.Challenge:
                    writer.Challenge.Init(Challenge);
                    break;
                case WHICH.Response:
                    writer.Response.Init(Response);
                    break;
                case WHICH.Outcome:
                    Outcome?.serialize(writer.Outcome);
                    break;
                case WHICH.Abort:
                    break;
            }
        }

        void ICapnpSerializable.Serialize(SerializerState arg_)
        {
            serialize(arg_.Rewrap<WRITER>());
        }

        public void applyDefaults()
        {
        }

        public IReadOnlyList<string> Mechanisms
        {
            get => _which == WHICH.Mechanisms ? (IReadOnlyList<string>)_content : null;
            set
            {
                _which = WHICH.Mechanisms;
                _content = value;
            }
        }

        public CapnpGen.Request Request
        {
            get => _which == WHICH.Request ? (CapnpGen.Request)_content : null;
            set
            {
                _which = WHICH.Request;
                _content = value;
            }
        }

        public IReadOnlyList<byte> Challenge
        {
            get => _which == WHICH.Challenge ? (IReadOnlyList<byte>)_content : null;
            set
            {
                _which = WHICH.Challenge;
                _content = value;
            }
        }

        public IReadOnlyList<byte> Response
        {
            get => _which == WHICH.Response ? (IReadOnlyList<byte>)_content : null;
            set
            {
                _which = WHICH.Response;
                _content = value;
            }
        }

        public CapnpGen.Outcome Outcome
        {
            get => _which == WHICH.Outcome ? (CapnpGen.Outcome)_content : null;
            set
            {
                _which = WHICH.Outcome;
                _content = value;
            }
        }

        public struct READER
        {
            readonly DeserializerState ctx;
            public READER(DeserializerState ctx)
            {
                this.ctx = ctx;
            }

            public static READER create(DeserializerState ctx) => new READER(ctx);
            public static implicit operator DeserializerState(READER reader) => reader.ctx;
            public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
            public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0);
            public IReadOnlyList<string> Mechanisms => which == WHICH.Mechanisms ? ctx.ReadList(0).CastText2() : default;
            public CapnpGen.Request.READER Request => which == WHICH.Request ? ctx.ReadStruct(0, CapnpGen.Request.READER.create) : default;
            public IReadOnlyList<byte> Challenge => which == WHICH.Challenge ? ctx.ReadList(0).CastByte() : default;
            public IReadOnlyList<byte> Response => which == WHICH.Response ? ctx.ReadList(0).CastByte() : default;
            public CapnpGen.Outcome.READER Outcome => which == WHICH.Outcome ? ctx.ReadStruct(0, CapnpGen.Outcome.READER.create) : default;
        }

        public class WRITER : SerializerState
        {
            public WRITER()
            {
                this.SetStruct(1, 1);
            }

            public WHICH which
            {
                get => (WHICH)this.ReadDataUShort(0U, (ushort)0);
                set => this.WriteData(0U, (ushort)value, (ushort)0);
            }

            public ListOfTextSerializer Mechanisms
            {
                get => which == WHICH.Mechanisms ? BuildPointer<ListOfTextSerializer>(0) : default;
                set => Link(0, value);
            }

            public CapnpGen.Request.WRITER Request
            {
                get => which == WHICH.Request ? BuildPointer<CapnpGen.Request.WRITER>(0) : default;
                set => Link(0, value);
            }

            public ListOfPrimitivesSerializer<byte> Challenge
            {
                get => which == WHICH.Challenge ? BuildPointer<ListOfPrimitivesSerializer<byte>>(0) : default;
                set => Link(0, value);
            }

            public ListOfPrimitivesSerializer<byte> Response
            {
                get => which == WHICH.Response ? BuildPointer<ListOfPrimitivesSerializer<byte>>(0) : default;
                set => Link(0, value);
            }

            public CapnpGen.Outcome.WRITER Outcome
            {
                get => which == WHICH.Outcome ? BuildPointer<CapnpGen.Outcome.WRITER>(0) : default;
                set => Link(0, value);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x80d8dfaa4dbfbb83UL)]
    public class Request : ICapnpSerializable
    {
        public const UInt64 typeId = 0x80d8dfaa4dbfbb83UL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            Mechanism = reader.Mechanism;
            InitialResponse = CapnpSerializable.Create<CapnpGen.Request.initialResponse>(reader.InitialResponse);
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.Mechanism = Mechanism;
            InitialResponse?.serialize(writer.InitialResponse);
        }

        void ICapnpSerializable.Serialize(SerializerState arg_)
        {
            serialize(arg_.Rewrap<WRITER>());
        }

        public void applyDefaults()
        {
        }

        public string Mechanism
        {
            get;
            set;
        }

        public CapnpGen.Request.initialResponse InitialResponse
        {
            get;
            set;
        }

        public struct READER
        {
            readonly DeserializerState ctx;
            public READER(DeserializerState ctx)
            {
                this.ctx = ctx;
            }

            public static READER create(DeserializerState ctx) => new READER(ctx);
            public static implicit operator DeserializerState(READER reader) => reader.ctx;
            public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
            public string Mechanism => ctx.ReadText(0, null);
            public initialResponse.READER InitialResponse => new initialResponse.READER(ctx);
        }

        public class WRITER : SerializerState
        {
            public WRITER()
            {
                this.SetStruct(1, 2);
            }

            public string Mechanism
            {
                get => this.ReadText(0, null);
                set => this.WriteText(0, value, null);
            }

            public initialResponse.WRITER InitialResponse
            {
                get => Rewrap<initialResponse.WRITER>();
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xcb5a6f246a9c7196UL)]
        public class initialResponse : ICapnpSerializable
        {
            public const UInt64 typeId = 0xcb5a6f246a9c7196UL;
            public enum WHICH : ushort
            {
                None = 0,
                Initial = 1,
                undefined = 65535
            }

            void ICapnpSerializable.Deserialize(DeserializerState arg_)
            {
                var reader = READER.create(arg_);
                switch (reader.which)
                {
                    case WHICH.None:
                        which = reader.which;
                        break;
                    case WHICH.Initial:
                        Initial = reader.Initial;
                        break;
                }

                applyDefaults();
            }

            private WHICH _which = WHICH.undefined;
            private object _content;
            public WHICH which
            {
                get => _which;
                set
                {
                    if (value == _which)
                        return;
                    _which = value;
                    switch (value)
                    {
                        case WHICH.None:
                            break;
                        case WHICH.Initial:
                            _content = null;
                            break;
                    }
                }
            }

            public void serialize(WRITER writer)
            {
                writer.which = which;
                switch (which)
                {
                    case WHICH.None:
                        break;
                    case WHICH.Initial:
                        writer.Initial.Init(Initial);
                        break;
                }
            }

            void ICapnpSerializable.Serialize(SerializerState arg_)
            {
                serialize(arg_.Rewrap<WRITER>());
            }

            public void applyDefaults()
            {
            }

            public IReadOnlyList<byte> Initial
            {
                get => _which == WHICH.Initial ? (IReadOnlyList<byte>)_content : null;
                set
                {
                    _which = WHICH.Initial;
                    _content = value;
                }
            }

            public struct READER
            {
                readonly DeserializerState ctx;
                public READER(DeserializerState ctx)
                {
                    this.ctx = ctx;
                }

                public static READER create(DeserializerState ctx) => new READER(ctx);
                public static implicit operator DeserializerState(READER reader) => reader.ctx;
                public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
                public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0);
                public IReadOnlyList<byte> Initial => which == WHICH.Initial ? ctx.ReadList(1).CastByte() : default;
            }

            public class WRITER : SerializerState
            {
                public WRITER()
                {
                }

                public WHICH which
                {
                    get => (WHICH)this.ReadDataUShort(0U, (ushort)0);
                    set => this.WriteData(0U, (ushort)value, (ushort)0);
                }

                public ListOfPrimitivesSerializer<byte> Initial
                {
                    get => which == WHICH.Initial ? BuildPointer<ListOfPrimitivesSerializer<byte>>(1) : default;
                    set => Link(1, value);
                }
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9f2f3c9cd9974434UL)]
    public class Outcome : ICapnpSerializable
    {
        public const UInt64 typeId = 0x9f2f3c9cd9974434UL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            TheResult = reader.TheResult;
            TheAction = reader.TheAction;
            HelpText = reader.HelpText;
            AdditionalData = CapnpSerializable.Create<CapnpGen.Outcome.additionalData>(reader.AdditionalData);
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.TheResult = TheResult;
            writer.TheAction = TheAction;
            writer.HelpText = HelpText;
            AdditionalData?.serialize(writer.AdditionalData);
        }

        void ICapnpSerializable.Serialize(SerializerState arg_)
        {
            serialize(arg_.Rewrap<WRITER>());
        }

        public void applyDefaults()
        {
        }

        public CapnpGen.Outcome.Result TheResult
        {
            get;
            set;
        }

        public CapnpGen.Outcome.Action TheAction
        {
            get;
            set;
        }

        public string HelpText
        {
            get;
            set;
        }

        public CapnpGen.Outcome.additionalData AdditionalData
        {
            get;
            set;
        }

        public struct READER
        {
            readonly DeserializerState ctx;
            public READER(DeserializerState ctx)
            {
                this.ctx = ctx;
            }

            public static READER create(DeserializerState ctx) => new READER(ctx);
            public static implicit operator DeserializerState(READER reader) => reader.ctx;
            public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
            public CapnpGen.Outcome.Result TheResult => (CapnpGen.Outcome.Result)ctx.ReadDataUShort(0UL, (ushort)0);
            public CapnpGen.Outcome.Action TheAction => (CapnpGen.Outcome.Action)ctx.ReadDataUShort(16UL, (ushort)0);
            public string HelpText => ctx.ReadText(0, null);
            public additionalData.READER AdditionalData => new additionalData.READER(ctx);
        }

        public class WRITER : SerializerState
        {
            public WRITER()
            {
                this.SetStruct(1, 2);
            }

            public CapnpGen.Outcome.Result TheResult
            {
                get => (CapnpGen.Outcome.Result)this.ReadDataUShort(0UL, (ushort)0);
                set => this.WriteData(0UL, (ushort)value, (ushort)0);
            }

            public CapnpGen.Outcome.Action TheAction
            {
                get => (CapnpGen.Outcome.Action)this.ReadDataUShort(16UL, (ushort)0);
                set => this.WriteData(16UL, (ushort)value, (ushort)0);
            }

            public string HelpText
            {
                get => this.ReadText(0, null);
                set => this.WriteText(0, value, null);
            }

            public additionalData.WRITER AdditionalData
            {
                get => Rewrap<additionalData.WRITER>();
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xcd5312ea76df43c1UL)]
        public class additionalData : ICapnpSerializable
        {
            public const UInt64 typeId = 0xcd5312ea76df43c1UL;
            public enum WHICH : ushort
            {
                None = 0,
                Additional = 1,
                undefined = 65535
            }

            void ICapnpSerializable.Deserialize(DeserializerState arg_)
            {
                var reader = READER.create(arg_);
                switch (reader.which)
                {
                    case WHICH.None:
                        which = reader.which;
                        break;
                    case WHICH.Additional:
                        Additional = reader.Additional;
                        break;
                }

                applyDefaults();
            }

            private WHICH _which = WHICH.undefined;
            private object _content;
            public WHICH which
            {
                get => _which;
                set
                {
                    if (value == _which)
                        return;
                    _which = value;
                    switch (value)
                    {
                        case WHICH.None:
                            break;
                        case WHICH.Additional:
                            _content = null;
                            break;
                    }
                }
            }

            public void serialize(WRITER writer)
            {
                writer.which = which;
                switch (which)
                {
                    case WHICH.None:
                        break;
                    case WHICH.Additional:
                        writer.Additional.Init(Additional);
                        break;
                }
            }

            void ICapnpSerializable.Serialize(SerializerState arg_)
            {
                serialize(arg_.Rewrap<WRITER>());
            }

            public void applyDefaults()
            {
            }

            public IReadOnlyList<byte> Additional
            {
                get => _which == WHICH.Additional ? (IReadOnlyList<byte>)_content : null;
                set
                {
                    _which = WHICH.Additional;
                    _content = value;
                }
            }

            public struct READER
            {
                readonly DeserializerState ctx;
                public READER(DeserializerState ctx)
                {
                    this.ctx = ctx;
                }

                public static READER create(DeserializerState ctx) => new READER(ctx);
                public static implicit operator DeserializerState(READER reader) => reader.ctx;
                public static implicit operator READER(DeserializerState ctx) => new READER(ctx);
                public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0);
                public IReadOnlyList<byte> Additional => which == WHICH.Additional ? ctx.ReadList(1).CastByte() : default;
            }

            public class WRITER : SerializerState
            {
                public WRITER()
                {
                }

                public WHICH which
                {
                    get => (WHICH)this.ReadDataUShort(32U, (ushort)0);
                    set => this.WriteData(32U, (ushort)value, (ushort)0);
                }

                public ListOfPrimitivesSerializer<byte> Additional
                {
                    get => which == WHICH.Additional ? BuildPointer<ListOfPrimitivesSerializer<byte>>(1) : default;
                    set => Link(1, value);
                }
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xf76eb72a8d2bf5f3UL)]
        public enum Result : ushort
        {
            successful,
            badMechanism,
            unwilling,
            invalidCredentials,
            unauthorized,
            malformedAuthZid,
            failed
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xbc1167ff63f623d0UL)]
        public enum Action : ushort
        {
            unset,
            retry,
            wait,
            permanent
        }
    }
}