libs.capnproto-dotnetcore_Runtime/Capnp.Net.Runtime/Rpc/rpc.cs

#pragma warning disable CS1591
using Capnp;
using Capnp.Rpc;
using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Threading;
using System.Threading.Tasks;

namespace Capnp.Rpc
{
    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x91b79f1f808db032UL)]
    public class Message : ICapnpSerializable
    {
        public const UInt64 typeId = 0x91b79f1f808db032UL;
        public enum WHICH : ushort
        {
            Unimplemented = 0,
            Abort = 1,
            Call = 2,
            Return = 3,
            Finish = 4,
            Resolve = 5,
            Release = 6,
            ObsoleteSave = 7,
            Bootstrap = 8,
            ObsoleteDelete = 9,
            Provide = 10,
            Accept = 11,
            Join = 12,
            Disembargo = 13,
            undefined = 65535
        }

        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            switch (reader.which)
            {
                case WHICH.Unimplemented:
                    Unimplemented = CapnpSerializable.Create<Capnp.Rpc.Message>(reader.Unimplemented);
                    break;
                case WHICH.Abort:
                    Abort = CapnpSerializable.Create<Capnp.Rpc.Exception>(reader.Abort);
                    break;
                case WHICH.Call:
                    Call = CapnpSerializable.Create<Capnp.Rpc.Call>(reader.Call);
                    break;
                case WHICH.Return:
                    Return = CapnpSerializable.Create<Capnp.Rpc.Return>(reader.Return);
                    break;
                case WHICH.Finish:
                    Finish = CapnpSerializable.Create<Capnp.Rpc.Finish>(reader.Finish);
                    break;
                case WHICH.Resolve:
                    Resolve = CapnpSerializable.Create<Capnp.Rpc.Resolve>(reader.Resolve);
                    break;
                case WHICH.Release:
                    Release = CapnpSerializable.Create<Capnp.Rpc.Release>(reader.Release);
                    break;
                case WHICH.ObsoleteSave:
                    ObsoleteSave = CapnpSerializable.Create<object>(reader.ObsoleteSave);
                    break;
                case WHICH.Bootstrap:
                    Bootstrap = CapnpSerializable.Create<Capnp.Rpc.Bootstrap>(reader.Bootstrap);
                    break;
                case WHICH.ObsoleteDelete:
                    ObsoleteDelete = CapnpSerializable.Create<object>(reader.ObsoleteDelete);
                    break;
                case WHICH.Provide:
                    Provide = CapnpSerializable.Create<Capnp.Rpc.Provide>(reader.Provide);
                    break;
                case WHICH.Accept:
                    Accept = CapnpSerializable.Create<Capnp.Rpc.Accept>(reader.Accept);
                    break;
                case WHICH.Join:
                    Join = CapnpSerializable.Create<Capnp.Rpc.Join>(reader.Join);
                    break;
                case WHICH.Disembargo:
                    Disembargo = CapnpSerializable.Create<Capnp.Rpc.Disembargo>(reader.Disembargo);
                    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.Unimplemented:
                        _content = null;
                        break;
                    case WHICH.Abort:
                        _content = null;
                        break;
                    case WHICH.Call:
                        _content = null;
                        break;
                    case WHICH.Return:
                        _content = null;
                        break;
                    case WHICH.Finish:
                        _content = null;
                        break;
                    case WHICH.Resolve:
                        _content = null;
                        break;
                    case WHICH.Release:
                        _content = null;
                        break;
                    case WHICH.ObsoleteSave:
                        _content = null;
                        break;
                    case WHICH.Bootstrap:
                        _content = null;
                        break;
                    case WHICH.ObsoleteDelete:
                        _content = null;
                        break;
                    case WHICH.Provide:
                        _content = null;
                        break;
                    case WHICH.Accept:
                        _content = null;
                        break;
                    case WHICH.Join:
                        _content = null;
                        break;
                    case WHICH.Disembargo:
                        _content = null;
                        break;
                }
            }
        }

        public void serialize(WRITER writer)
        {
            writer.which = which;
            switch (which)
            {
                case WHICH.Unimplemented:
                    Unimplemented?.serialize(writer.Unimplemented!);
                    break;
                case WHICH.Abort:
                    Abort?.serialize(writer.Abort!);
                    break;
                case WHICH.Call:
                    Call?.serialize(writer.Call!);
                    break;
                case WHICH.Return:
                    Return?.serialize(writer.Return!);
                    break;
                case WHICH.Finish:
                    Finish?.serialize(writer.Finish!);
                    break;
                case WHICH.Resolve:
                    Resolve?.serialize(writer.Resolve!);
                    break;
                case WHICH.Release:
                    Release?.serialize(writer.Release!);
                    break;
                case WHICH.ObsoleteSave:
                    writer.ObsoleteSave!.SetObject(ObsoleteSave);
                    break;
                case WHICH.Bootstrap:
                    Bootstrap?.serialize(writer.Bootstrap!);
                    break;
                case WHICH.ObsoleteDelete:
                    writer.ObsoleteDelete!.SetObject(ObsoleteDelete);
                    break;
                case WHICH.Provide:
                    Provide?.serialize(writer.Provide!);
                    break;
                case WHICH.Accept:
                    Accept?.serialize(writer.Accept!);
                    break;
                case WHICH.Join:
                    Join?.serialize(writer.Join!);
                    break;
                case WHICH.Disembargo:
                    Disembargo?.serialize(writer.Disembargo!);
                    break;
            }
        }

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

        public void applyDefaults()
        {
        }

        public Capnp.Rpc.Message? Unimplemented
        {
            get => _which == WHICH.Unimplemented ? (Capnp.Rpc.Message?)_content : null;
            set
            {
                _which = WHICH.Unimplemented;
                _content = value;
            }
        }

        public Capnp.Rpc.Exception? Abort
        {
            get => _which == WHICH.Abort ? (Capnp.Rpc.Exception?)_content : null;
            set
            {
                _which = WHICH.Abort;
                _content = value;
            }
        }

        public Capnp.Rpc.Call? Call
        {
            get => _which == WHICH.Call ? (Capnp.Rpc.Call?)_content : null;
            set
            {
                _which = WHICH.Call;
                _content = value;
            }
        }

        public Capnp.Rpc.Return? Return
        {
            get => _which == WHICH.Return ? (Capnp.Rpc.Return?)_content : null;
            set
            {
                _which = WHICH.Return;
                _content = value;
            }
        }

        public Capnp.Rpc.Finish? Finish
        {
            get => _which == WHICH.Finish ? (Capnp.Rpc.Finish?)_content : null;
            set
            {
                _which = WHICH.Finish;
                _content = value;
            }
        }

        public Capnp.Rpc.Resolve? Resolve
        {
            get => _which == WHICH.Resolve ? (Capnp.Rpc.Resolve?)_content : null;
            set
            {
                _which = WHICH.Resolve;
                _content = value;
            }
        }

        public Capnp.Rpc.Release? Release
        {
            get => _which == WHICH.Release ? (Capnp.Rpc.Release?)_content : null;
            set
            {
                _which = WHICH.Release;
                _content = value;
            }
        }

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

        public Capnp.Rpc.Bootstrap? Bootstrap
        {
            get => _which == WHICH.Bootstrap ? (Capnp.Rpc.Bootstrap?)_content : null;
            set
            {
                _which = WHICH.Bootstrap;
                _content = value;
            }
        }

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

        public Capnp.Rpc.Provide? Provide
        {
            get => _which == WHICH.Provide ? (Capnp.Rpc.Provide?)_content : null;
            set
            {
                _which = WHICH.Provide;
                _content = value;
            }
        }

        public Capnp.Rpc.Accept? Accept
        {
            get => _which == WHICH.Accept ? (Capnp.Rpc.Accept?)_content : null;
            set
            {
                _which = WHICH.Accept;
                _content = value;
            }
        }

        public Capnp.Rpc.Join? Join
        {
            get => _which == WHICH.Join ? (Capnp.Rpc.Join?)_content : null;
            set
            {
                _which = WHICH.Join;
                _content = value;
            }
        }

        public Capnp.Rpc.Disembargo? Disembargo
        {
            get => _which == WHICH.Disembargo ? (Capnp.Rpc.Disembargo?)_content : null;
            set
            {
                _which = WHICH.Disembargo;
                _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 Capnp.Rpc.Message.READER Unimplemented => which == WHICH.Unimplemented ? ctx.ReadStruct(0, Capnp.Rpc.Message.READER.create) : default;
            public Capnp.Rpc.Exception.READER Abort => which == WHICH.Abort ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default;
            public Capnp.Rpc.Call.READER Call => which == WHICH.Call ? ctx.ReadStruct(0, Capnp.Rpc.Call.READER.create) : default;
            public Capnp.Rpc.Return.READER Return => which == WHICH.Return ? ctx.ReadStruct(0, Capnp.Rpc.Return.READER.create) : default;
            public Capnp.Rpc.Finish.READER Finish => which == WHICH.Finish ? ctx.ReadStruct(0, Capnp.Rpc.Finish.READER.create) : default;
            public Capnp.Rpc.Resolve.READER Resolve => which == WHICH.Resolve ? ctx.ReadStruct(0, Capnp.Rpc.Resolve.READER.create) : default;
            public Capnp.Rpc.Release.READER Release => which == WHICH.Release ? ctx.ReadStruct(0, Capnp.Rpc.Release.READER.create) : default;
            public DeserializerState ObsoleteSave => which == WHICH.ObsoleteSave ? ctx.StructReadPointer(0) : default;
            public Capnp.Rpc.Bootstrap.READER Bootstrap => which == WHICH.Bootstrap ? ctx.ReadStruct(0, Capnp.Rpc.Bootstrap.READER.create) : default;
            public DeserializerState ObsoleteDelete => which == WHICH.ObsoleteDelete ? ctx.StructReadPointer(0) : default;
            public Capnp.Rpc.Provide.READER Provide => which == WHICH.Provide ? ctx.ReadStruct(0, Capnp.Rpc.Provide.READER.create) : default;
            public Capnp.Rpc.Accept.READER Accept => which == WHICH.Accept ? ctx.ReadStruct(0, Capnp.Rpc.Accept.READER.create) : default;
            public Capnp.Rpc.Join.READER Join => which == WHICH.Join ? ctx.ReadStruct(0, Capnp.Rpc.Join.READER.create) : default;
            public Capnp.Rpc.Disembargo.READER Disembargo => which == WHICH.Disembargo ? ctx.ReadStruct(0, Capnp.Rpc.Disembargo.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);
            }

            [DisallowNull]
            public Capnp.Rpc.Message.WRITER? Unimplemented
            {
                get => which == WHICH.Unimplemented ? BuildPointer<Capnp.Rpc.Message.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Exception.WRITER? Abort
            {
                get => which == WHICH.Abort ? BuildPointer<Capnp.Rpc.Exception.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Call.WRITER? Call
            {
                get => which == WHICH.Call ? BuildPointer<Capnp.Rpc.Call.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Return.WRITER? Return
            {
                get => which == WHICH.Return ? BuildPointer<Capnp.Rpc.Return.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Finish.WRITER? Finish
            {
                get => which == WHICH.Finish ? BuildPointer<Capnp.Rpc.Finish.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Resolve.WRITER? Resolve
            {
                get => which == WHICH.Resolve ? BuildPointer<Capnp.Rpc.Resolve.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Release.WRITER? Release
            {
                get => which == WHICH.Release ? BuildPointer<Capnp.Rpc.Release.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public DynamicSerializerState? ObsoleteSave
            {
                get => which == WHICH.ObsoleteSave ? BuildPointer<DynamicSerializerState>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Bootstrap.WRITER? Bootstrap
            {
                get => which == WHICH.Bootstrap ? BuildPointer<Capnp.Rpc.Bootstrap.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public DynamicSerializerState? ObsoleteDelete
            {
                get => which == WHICH.ObsoleteDelete ? BuildPointer<DynamicSerializerState>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Provide.WRITER? Provide
            {
                get => which == WHICH.Provide ? BuildPointer<Capnp.Rpc.Provide.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Accept.WRITER? Accept
            {
                get => which == WHICH.Accept ? BuildPointer<Capnp.Rpc.Accept.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Join.WRITER? Join
            {
                get => which == WHICH.Join ? BuildPointer<Capnp.Rpc.Join.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Disembargo.WRITER? Disembargo
            {
                get => which == WHICH.Disembargo ? BuildPointer<Capnp.Rpc.Disembargo.WRITER>(0) : default;
                set => Link(0, value!);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xe94ccf8031176ec4UL)]
    public class Bootstrap : ICapnpSerializable
    {
        public const UInt64 typeId = 0xe94ccf8031176ec4UL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            QuestionId = reader.QuestionId;
            DeprecatedObjectId = CapnpSerializable.Create<object>(reader.DeprecatedObjectId);
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.QuestionId = QuestionId;
            writer.DeprecatedObjectId.SetObject(DeprecatedObjectId);
        }

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

        public void applyDefaults()
        {
        }

        public uint QuestionId
        {
            get;
            set;
        }

        public object? DeprecatedObjectId
        {
            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 uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
            public DeserializerState DeprecatedObjectId => ctx.StructReadPointer(0);
        }

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

            public uint QuestionId
            {
                get => this.ReadDataUInt(0UL, 0U);
                set => this.WriteData(0UL, value, 0U);
            }

            public DynamicSerializerState DeprecatedObjectId
            {
                get => BuildPointer<DynamicSerializerState>(0);
                set => Link(0, value);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x836a53ce789d4cd4UL)]
    public class Call : ICapnpSerializable
    {
        public const UInt64 typeId = 0x836a53ce789d4cd4UL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            QuestionId = reader.QuestionId;
            Target = CapnpSerializable.Create<Capnp.Rpc.MessageTarget>(reader.Target);
            InterfaceId = reader.InterfaceId;
            MethodId = reader.MethodId;
            Params = CapnpSerializable.Create<Capnp.Rpc.Payload>(reader.Params);
            SendResultsTo = CapnpSerializable.Create<Capnp.Rpc.Call.sendResultsTo>(reader.SendResultsTo);
            AllowThirdPartyTailCall = reader.AllowThirdPartyTailCall;
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.QuestionId = QuestionId;
            Target?.serialize(writer.Target);
            writer.InterfaceId = InterfaceId;
            writer.MethodId = MethodId;
            Params?.serialize(writer.Params);
            SendResultsTo?.serialize(writer.SendResultsTo);
            writer.AllowThirdPartyTailCall = AllowThirdPartyTailCall;
        }

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

        public void applyDefaults()
        {
        }

        public uint QuestionId
        {
            get;
            set;
        }

        public Capnp.Rpc.MessageTarget? Target
        {
            get;
            set;
        }

        public ulong InterfaceId
        {
            get;
            set;
        }

        public ushort MethodId
        {
            get;
            set;
        }

        public Capnp.Rpc.Payload? Params
        {
            get;
            set;
        }

        public Capnp.Rpc.Call.sendResultsTo? SendResultsTo
        {
            get;
            set;
        }

        public bool AllowThirdPartyTailCall
        {
            get;
            set;
        }

        = false;
        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 uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
            public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create);
            public ulong InterfaceId => ctx.ReadDataULong(64UL, 0UL);
            public ushort MethodId => ctx.ReadDataUShort(32UL, (ushort)0);
            public Capnp.Rpc.Payload.READER Params => ctx.ReadStruct(1, Capnp.Rpc.Payload.READER.create);
            public sendResultsTo.READER SendResultsTo => new sendResultsTo.READER(ctx);
            public bool AllowThirdPartyTailCall => ctx.ReadDataBool(128UL, false);
        }

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

            public uint QuestionId
            {
                get => this.ReadDataUInt(0UL, 0U);
                set => this.WriteData(0UL, value, 0U);
            }

            public Capnp.Rpc.MessageTarget.WRITER Target
            {
                get => BuildPointer<Capnp.Rpc.MessageTarget.WRITER>(0);
                set => Link(0, value);
            }

            public ulong InterfaceId
            {
                get => this.ReadDataULong(64UL, 0UL);
                set => this.WriteData(64UL, value, 0UL);
            }

            public ushort MethodId
            {
                get => this.ReadDataUShort(32UL, (ushort)0);
                set => this.WriteData(32UL, value, (ushort)0);
            }

            public Capnp.Rpc.Payload.WRITER Params
            {
                get => BuildPointer<Capnp.Rpc.Payload.WRITER>(1);
                set => Link(1, value);
            }

            public sendResultsTo.WRITER SendResultsTo
            {
                get => Rewrap<sendResultsTo.WRITER>();
            }

            public bool AllowThirdPartyTailCall
            {
                get => this.ReadDataBool(128UL, false);
                set => this.WriteData(128UL, value, false);
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xdae8b0f61aab5f99UL)]
        public class sendResultsTo : ICapnpSerializable
        {
            public const UInt64 typeId = 0xdae8b0f61aab5f99UL;
            public enum WHICH : ushort
            {
                Caller = 0,
                Yourself = 1,
                ThirdParty = 2,
                undefined = 65535
            }

            void ICapnpSerializable.Deserialize(DeserializerState arg_)
            {
                var reader = READER.create(arg_);
                switch (reader.which)
                {
                    case WHICH.Caller:
                        which = reader.which;
                        break;
                    case WHICH.Yourself:
                        which = reader.which;
                        break;
                    case WHICH.ThirdParty:
                        ThirdParty = CapnpSerializable.Create<object>(reader.ThirdParty);
                        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.Caller:
                            break;
                        case WHICH.Yourself:
                            break;
                        case WHICH.ThirdParty:
                            _content = null;
                            break;
                    }
                }
            }

            public void serialize(WRITER writer)
            {
                writer.which = which;
                switch (which)
                {
                    case WHICH.Caller:
                        break;
                    case WHICH.Yourself:
                        break;
                    case WHICH.ThirdParty:
                        writer.ThirdParty!.SetObject(ThirdParty);
                        break;
                }
            }

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

            public void applyDefaults()
            {
            }

            public object? ThirdParty
            {
                get => _which == WHICH.ThirdParty ? (object?)_content : null;
                set
                {
                    _which = WHICH.ThirdParty;
                    _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(48U, (ushort)0);
                public DeserializerState ThirdParty => which == WHICH.ThirdParty ? ctx.StructReadPointer(2) : default;
            }

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

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

                [DisallowNull]
                public DynamicSerializerState? ThirdParty
                {
                    get => which == WHICH.ThirdParty ? BuildPointer<DynamicSerializerState>(2) : default;
                    set => Link(2, value!);
                }
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9e19b28d3db3573aUL)]
    public class Return : ICapnpSerializable
    {
        public const UInt64 typeId = 0x9e19b28d3db3573aUL;
        public enum WHICH : ushort
        {
            Results = 0,
            Exception = 1,
            Canceled = 2,
            ResultsSentElsewhere = 3,
            TakeFromOtherQuestion = 4,
            AcceptFromThirdParty = 5,
            undefined = 65535
        }

        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            switch (reader.which)
            {
                case WHICH.Results:
                    Results = CapnpSerializable.Create<Capnp.Rpc.Payload>(reader.Results);
                    break;
                case WHICH.Exception:
                    Exception = CapnpSerializable.Create<Capnp.Rpc.Exception>(reader.Exception);
                    break;
                case WHICH.Canceled:
                    which = reader.which;
                    break;
                case WHICH.ResultsSentElsewhere:
                    which = reader.which;
                    break;
                case WHICH.TakeFromOtherQuestion:
                    TakeFromOtherQuestion = reader.TakeFromOtherQuestion;
                    break;
                case WHICH.AcceptFromThirdParty:
                    AcceptFromThirdParty = CapnpSerializable.Create<object>(reader.AcceptFromThirdParty);
                    break;
            }

            AnswerId = reader.AnswerId;
            ReleaseParamCaps = reader.ReleaseParamCaps;
            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.Results:
                        _content = null;
                        break;
                    case WHICH.Exception:
                        _content = null;
                        break;
                    case WHICH.Canceled:
                        break;
                    case WHICH.ResultsSentElsewhere:
                        break;
                    case WHICH.TakeFromOtherQuestion:
                        _content = 0;
                        break;
                    case WHICH.AcceptFromThirdParty:
                        _content = null;
                        break;
                }
            }
        }

        public void serialize(WRITER writer)
        {
            writer.which = which;
            switch (which)
            {
                case WHICH.Results:
                    Results?.serialize(writer.Results!);
                    break;
                case WHICH.Exception:
                    Exception?.serialize(writer.Exception!);
                    break;
                case WHICH.Canceled:
                    break;
                case WHICH.ResultsSentElsewhere:
                    break;
                case WHICH.TakeFromOtherQuestion:
                    writer.TakeFromOtherQuestion = TakeFromOtherQuestion!.Value;
                    break;
                case WHICH.AcceptFromThirdParty:
                    writer.AcceptFromThirdParty!.SetObject(AcceptFromThirdParty);
                    break;
            }

            writer.AnswerId = AnswerId;
            writer.ReleaseParamCaps = ReleaseParamCaps;
        }

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

        public void applyDefaults()
        {
        }

        public uint AnswerId
        {
            get;
            set;
        }

        public bool ReleaseParamCaps
        {
            get;
            set;
        }

        = true;
        public Capnp.Rpc.Payload? Results
        {
            get => _which == WHICH.Results ? (Capnp.Rpc.Payload?)_content : null;
            set
            {
                _which = WHICH.Results;
                _content = value;
            }
        }

        public Capnp.Rpc.Exception? Exception
        {
            get => _which == WHICH.Exception ? (Capnp.Rpc.Exception?)_content : null;
            set
            {
                _which = WHICH.Exception;
                _content = value;
            }
        }

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

        public object? AcceptFromThirdParty
        {
            get => _which == WHICH.AcceptFromThirdParty ? (object?)_content : null;
            set
            {
                _which = WHICH.AcceptFromThirdParty;
                _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(48U, (ushort)0);
            public uint AnswerId => ctx.ReadDataUInt(0UL, 0U);
            public bool ReleaseParamCaps => ctx.ReadDataBool(32UL, true);
            public Capnp.Rpc.Payload.READER Results => which == WHICH.Results ? ctx.ReadStruct(0, Capnp.Rpc.Payload.READER.create) : default;
            public Capnp.Rpc.Exception.READER Exception => which == WHICH.Exception ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default;
            public uint TakeFromOtherQuestion => which == WHICH.TakeFromOtherQuestion ? ctx.ReadDataUInt(64UL, 0U) : default;
            public DeserializerState AcceptFromThirdParty => which == WHICH.AcceptFromThirdParty ? ctx.StructReadPointer(0) : default;
        }

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

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

            public uint AnswerId
            {
                get => this.ReadDataUInt(0UL, 0U);
                set => this.WriteData(0UL, value, 0U);
            }

            public bool ReleaseParamCaps
            {
                get => this.ReadDataBool(32UL, true);
                set => this.WriteData(32UL, value, true);
            }

            [DisallowNull]
            public Capnp.Rpc.Payload.WRITER? Results
            {
                get => which == WHICH.Results ? BuildPointer<Capnp.Rpc.Payload.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Exception.WRITER? Exception
            {
                get => which == WHICH.Exception ? BuildPointer<Capnp.Rpc.Exception.WRITER>(0) : default;
                set => Link(0, value!);
            }

            public uint TakeFromOtherQuestion
            {
                get => which == WHICH.TakeFromOtherQuestion ? this.ReadDataUInt(64UL, 0U) : default;
                set => this.WriteData(64UL, value, 0U);
            }

            [DisallowNull]
            public DynamicSerializerState? AcceptFromThirdParty
            {
                get => which == WHICH.AcceptFromThirdParty ? BuildPointer<DynamicSerializerState>(0) : default;
                set => Link(0, value!);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xd37d2eb2c2f80e63UL)]
    public class Finish : ICapnpSerializable
    {
        public const UInt64 typeId = 0xd37d2eb2c2f80e63UL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            QuestionId = reader.QuestionId;
            ReleaseResultCaps = reader.ReleaseResultCaps;
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.QuestionId = QuestionId;
            writer.ReleaseResultCaps = ReleaseResultCaps;
        }

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

        public void applyDefaults()
        {
        }

        public uint QuestionId
        {
            get;
            set;
        }

        public bool ReleaseResultCaps
        {
            get;
            set;
        }

        = true;
        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 uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
            public bool ReleaseResultCaps => ctx.ReadDataBool(32UL, true);
        }

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

            public uint QuestionId
            {
                get => this.ReadDataUInt(0UL, 0U);
                set => this.WriteData(0UL, value, 0U);
            }

            public bool ReleaseResultCaps
            {
                get => this.ReadDataBool(32UL, true);
                set => this.WriteData(32UL, value, true);
            }
        }
    }

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

        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            switch (reader.which)
            {
                case WHICH.Cap:
                    Cap = CapnpSerializable.Create<Capnp.Rpc.CapDescriptor>(reader.Cap);
                    break;
                case WHICH.Exception:
                    Exception = CapnpSerializable.Create<Capnp.Rpc.Exception>(reader.Exception);
                    break;
            }

            PromiseId = reader.PromiseId;
            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.Cap:
                        _content = null;
                        break;
                    case WHICH.Exception:
                        _content = null;
                        break;
                }
            }
        }

        public void serialize(WRITER writer)
        {
            writer.which = which;
            switch (which)
            {
                case WHICH.Cap:
                    Cap?.serialize(writer.Cap!);
                    break;
                case WHICH.Exception:
                    Exception?.serialize(writer.Exception!);
                    break;
            }

            writer.PromiseId = PromiseId;
        }

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

        public void applyDefaults()
        {
        }

        public uint PromiseId
        {
            get;
            set;
        }

        public Capnp.Rpc.CapDescriptor? Cap
        {
            get => _which == WHICH.Cap ? (Capnp.Rpc.CapDescriptor?)_content : null;
            set
            {
                _which = WHICH.Cap;
                _content = value;
            }
        }

        public Capnp.Rpc.Exception? Exception
        {
            get => _which == WHICH.Exception ? (Capnp.Rpc.Exception?)_content : null;
            set
            {
                _which = WHICH.Exception;
                _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 uint PromiseId => ctx.ReadDataUInt(0UL, 0U);
            public Capnp.Rpc.CapDescriptor.READER Cap => which == WHICH.Cap ? ctx.ReadStruct(0, Capnp.Rpc.CapDescriptor.READER.create) : default;
            public Capnp.Rpc.Exception.READER Exception => which == WHICH.Exception ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default;
        }

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

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

            public uint PromiseId
            {
                get => this.ReadDataUInt(0UL, 0U);
                set => this.WriteData(0UL, value, 0U);
            }

            [DisallowNull]
            public Capnp.Rpc.CapDescriptor.WRITER? Cap
            {
                get => which == WHICH.Cap ? BuildPointer<Capnp.Rpc.CapDescriptor.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.Exception.WRITER? Exception
            {
                get => which == WHICH.Exception ? BuildPointer<Capnp.Rpc.Exception.WRITER>(0) : default;
                set => Link(0, value!);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xad1a6c0d7dd07497UL)]
    public class Release : ICapnpSerializable
    {
        public const UInt64 typeId = 0xad1a6c0d7dd07497UL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            Id = reader.Id;
            ReferenceCount = reader.ReferenceCount;
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.Id = Id;
            writer.ReferenceCount = ReferenceCount;
        }

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

        public void applyDefaults()
        {
        }

        public uint Id
        {
            get;
            set;
        }

        public uint ReferenceCount
        {
            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 uint Id => ctx.ReadDataUInt(0UL, 0U);
            public uint ReferenceCount => ctx.ReadDataUInt(32UL, 0U);
        }

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

            public uint Id
            {
                get => this.ReadDataUInt(0UL, 0U);
                set => this.WriteData(0UL, value, 0U);
            }

            public uint ReferenceCount
            {
                get => this.ReadDataUInt(32UL, 0U);
                set => this.WriteData(32UL, value, 0U);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xf964368b0fbd3711UL)]
    public class Disembargo : ICapnpSerializable
    {
        public const UInt64 typeId = 0xf964368b0fbd3711UL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            Target = CapnpSerializable.Create<Capnp.Rpc.MessageTarget>(reader.Target);
            Context = CapnpSerializable.Create<Capnp.Rpc.Disembargo.context>(reader.Context);
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            Target?.serialize(writer.Target);
            Context?.serialize(writer.Context);
        }

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

        public void applyDefaults()
        {
        }

        public Capnp.Rpc.MessageTarget? Target
        {
            get;
            set;
        }

        public Capnp.Rpc.Disembargo.context? Context
        {
            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 Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create);
            public context.READER Context => new context.READER(ctx);
        }

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

            public Capnp.Rpc.MessageTarget.WRITER Target
            {
                get => BuildPointer<Capnp.Rpc.MessageTarget.WRITER>(0);
                set => Link(0, value);
            }

            public context.WRITER Context
            {
                get => Rewrap<context.WRITER>();
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xd562b4df655bdd4dUL)]
        public class context : ICapnpSerializable
        {
            public const UInt64 typeId = 0xd562b4df655bdd4dUL;
            public enum WHICH : ushort
            {
                SenderLoopback = 0,
                ReceiverLoopback = 1,
                Accept = 2,
                Provide = 3,
                undefined = 65535
            }

            void ICapnpSerializable.Deserialize(DeserializerState arg_)
            {
                var reader = READER.create(arg_);
                switch (reader.which)
                {
                    case WHICH.SenderLoopback:
                        SenderLoopback = reader.SenderLoopback;
                        break;
                    case WHICH.ReceiverLoopback:
                        ReceiverLoopback = reader.ReceiverLoopback;
                        break;
                    case WHICH.Accept:
                        which = reader.which;
                        break;
                    case WHICH.Provide:
                        Provide = reader.Provide;
                        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.SenderLoopback:
                            _content = 0;
                            break;
                        case WHICH.ReceiverLoopback:
                            _content = 0;
                            break;
                        case WHICH.Accept:
                            break;
                        case WHICH.Provide:
                            _content = 0;
                            break;
                    }
                }
            }

            public void serialize(WRITER writer)
            {
                writer.which = which;
                switch (which)
                {
                    case WHICH.SenderLoopback:
                        writer.SenderLoopback = SenderLoopback!.Value;
                        break;
                    case WHICH.ReceiverLoopback:
                        writer.ReceiverLoopback = ReceiverLoopback!.Value;
                        break;
                    case WHICH.Accept:
                        break;
                    case WHICH.Provide:
                        writer.Provide = Provide!.Value;
                        break;
                }
            }

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

            public void applyDefaults()
            {
            }

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

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

            public uint? Provide
            {
                get => _which == WHICH.Provide ? (uint?)_content : null;
                set
                {
                    _which = WHICH.Provide;
                    _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 uint SenderLoopback => which == WHICH.SenderLoopback ? ctx.ReadDataUInt(0UL, 0U) : default;
                public uint ReceiverLoopback => which == WHICH.ReceiverLoopback ? ctx.ReadDataUInt(0UL, 0U) : default;
                public uint Provide => which == WHICH.Provide ? ctx.ReadDataUInt(0UL, 0U) : 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 uint SenderLoopback
                {
                    get => which == WHICH.SenderLoopback ? this.ReadDataUInt(0UL, 0U) : default;
                    set => this.WriteData(0UL, value, 0U);
                }

                public uint ReceiverLoopback
                {
                    get => which == WHICH.ReceiverLoopback ? this.ReadDataUInt(0UL, 0U) : default;
                    set => this.WriteData(0UL, value, 0U);
                }

                public uint Provide
                {
                    get => which == WHICH.Provide ? this.ReadDataUInt(0UL, 0U) : default;
                    set => this.WriteData(0UL, value, 0U);
                }
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9c6a046bfbc1ac5aUL)]
    public class Provide : ICapnpSerializable
    {
        public const UInt64 typeId = 0x9c6a046bfbc1ac5aUL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            QuestionId = reader.QuestionId;
            Target = CapnpSerializable.Create<Capnp.Rpc.MessageTarget>(reader.Target);
            Recipient = CapnpSerializable.Create<object>(reader.Recipient);
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.QuestionId = QuestionId;
            Target?.serialize(writer.Target);
            writer.Recipient.SetObject(Recipient);
        }

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

        public void applyDefaults()
        {
        }

        public uint QuestionId
        {
            get;
            set;
        }

        public Capnp.Rpc.MessageTarget? Target
        {
            get;
            set;
        }

        public object? Recipient
        {
            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 uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
            public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create);
            public DeserializerState Recipient => ctx.StructReadPointer(1);
        }

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

            public uint QuestionId
            {
                get => this.ReadDataUInt(0UL, 0U);
                set => this.WriteData(0UL, value, 0U);
            }

            public Capnp.Rpc.MessageTarget.WRITER Target
            {
                get => BuildPointer<Capnp.Rpc.MessageTarget.WRITER>(0);
                set => Link(0, value);
            }

            public DynamicSerializerState Recipient
            {
                get => BuildPointer<DynamicSerializerState>(1);
                set => Link(1, value);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xd4c9b56290554016UL)]
    public class Accept : ICapnpSerializable
    {
        public const UInt64 typeId = 0xd4c9b56290554016UL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            QuestionId = reader.QuestionId;
            Provision = CapnpSerializable.Create<object>(reader.Provision);
            Embargo = reader.Embargo;
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.QuestionId = QuestionId;
            writer.Provision.SetObject(Provision);
            writer.Embargo = Embargo;
        }

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

        public void applyDefaults()
        {
        }

        public uint QuestionId
        {
            get;
            set;
        }

        public object? Provision
        {
            get;
            set;
        }

        public bool Embargo
        {
            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 uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
            public DeserializerState Provision => ctx.StructReadPointer(0);
            public bool Embargo => ctx.ReadDataBool(32UL, false);
        }

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

            public uint QuestionId
            {
                get => this.ReadDataUInt(0UL, 0U);
                set => this.WriteData(0UL, value, 0U);
            }

            public DynamicSerializerState Provision
            {
                get => BuildPointer<DynamicSerializerState>(0);
                set => Link(0, value);
            }

            public bool Embargo
            {
                get => this.ReadDataBool(32UL, false);
                set => this.WriteData(32UL, value, false);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xfbe1980490e001afUL)]
    public class Join : ICapnpSerializable
    {
        public const UInt64 typeId = 0xfbe1980490e001afUL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            QuestionId = reader.QuestionId;
            Target = CapnpSerializable.Create<Capnp.Rpc.MessageTarget>(reader.Target);
            KeyPart = CapnpSerializable.Create<object>(reader.KeyPart);
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.QuestionId = QuestionId;
            Target?.serialize(writer.Target);
            writer.KeyPart.SetObject(KeyPart);
        }

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

        public void applyDefaults()
        {
        }

        public uint QuestionId
        {
            get;
            set;
        }

        public Capnp.Rpc.MessageTarget? Target
        {
            get;
            set;
        }

        public object? KeyPart
        {
            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 uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
            public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create);
            public DeserializerState KeyPart => ctx.StructReadPointer(1);
        }

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

            public uint QuestionId
            {
                get => this.ReadDataUInt(0UL, 0U);
                set => this.WriteData(0UL, value, 0U);
            }

            public Capnp.Rpc.MessageTarget.WRITER Target
            {
                get => BuildPointer<Capnp.Rpc.MessageTarget.WRITER>(0);
                set => Link(0, value);
            }

            public DynamicSerializerState KeyPart
            {
                get => BuildPointer<DynamicSerializerState>(1);
                set => Link(1, value);
            }
        }
    }

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

        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            switch (reader.which)
            {
                case WHICH.ImportedCap:
                    ImportedCap = reader.ImportedCap;
                    break;
                case WHICH.PromisedAnswer:
                    PromisedAnswer = CapnpSerializable.Create<Capnp.Rpc.PromisedAnswer>(reader.PromisedAnswer);
                    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.ImportedCap:
                        _content = 0;
                        break;
                    case WHICH.PromisedAnswer:
                        _content = null;
                        break;
                }
            }
        }

        public void serialize(WRITER writer)
        {
            writer.which = which;
            switch (which)
            {
                case WHICH.ImportedCap:
                    writer.ImportedCap = ImportedCap!.Value;
                    break;
                case WHICH.PromisedAnswer:
                    PromisedAnswer?.serialize(writer.PromisedAnswer!);
                    break;
            }
        }

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

        public void applyDefaults()
        {
        }

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

        public Capnp.Rpc.PromisedAnswer? PromisedAnswer
        {
            get => _which == WHICH.PromisedAnswer ? (Capnp.Rpc.PromisedAnswer?)_content : null;
            set
            {
                _which = WHICH.PromisedAnswer;
                _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 uint ImportedCap => which == WHICH.ImportedCap ? ctx.ReadDataUInt(0UL, 0U) : default;
            public Capnp.Rpc.PromisedAnswer.READER PromisedAnswer => which == WHICH.PromisedAnswer ? ctx.ReadStruct(0, Capnp.Rpc.PromisedAnswer.READER.create) : default;
        }

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

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

            public uint ImportedCap
            {
                get => which == WHICH.ImportedCap ? this.ReadDataUInt(0UL, 0U) : default;
                set => this.WriteData(0UL, value, 0U);
            }

            [DisallowNull]
            public Capnp.Rpc.PromisedAnswer.WRITER? PromisedAnswer
            {
                get => which == WHICH.PromisedAnswer ? BuildPointer<Capnp.Rpc.PromisedAnswer.WRITER>(0) : default;
                set => Link(0, value!);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9a0e61223d96743bUL)]
    public class Payload : ICapnpSerializable
    {
        public const UInt64 typeId = 0x9a0e61223d96743bUL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            Content = CapnpSerializable.Create<object>(reader.Content);
            CapTable = reader.CapTable?.ToReadOnlyList(_ => CapnpSerializable.Create<Capnp.Rpc.CapDescriptor>(_)!);
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.Content.SetObject(Content);
            writer.CapTable.Init(CapTable, (_s1, _v1) => _v1?.serialize(_s1));
        }

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

        public void applyDefaults()
        {
        }

        public object? Content
        {
            get;
            set;
        }

        public IReadOnlyList<Capnp.Rpc.CapDescriptor>? CapTable
        {
            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 DeserializerState Content => ctx.StructReadPointer(0);
            public IReadOnlyList<Capnp.Rpc.CapDescriptor.READER> CapTable => ctx.ReadList(1).Cast(Capnp.Rpc.CapDescriptor.READER.create);
        }

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

            public DynamicSerializerState Content
            {
                get => BuildPointer<DynamicSerializerState>(0);
                set => Link(0, value);
            }

            public ListOfStructsSerializer<Capnp.Rpc.CapDescriptor.WRITER> CapTable
            {
                get => BuildPointer<ListOfStructsSerializer<Capnp.Rpc.CapDescriptor.WRITER>>(1);
                set => Link(1, value);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8523ddc40b86b8b0UL)]
    public class CapDescriptor : ICapnpSerializable
    {
        public const UInt64 typeId = 0x8523ddc40b86b8b0UL;
        public enum WHICH : ushort
        {
            None = 0,
            SenderHosted = 1,
            SenderPromise = 2,
            ReceiverHosted = 3,
            ReceiverAnswer = 4,
            ThirdPartyHosted = 5,
            undefined = 65535
        }

        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            switch (reader.which)
            {
                case WHICH.None:
                    which = reader.which;
                    break;
                case WHICH.SenderHosted:
                    SenderHosted = reader.SenderHosted;
                    break;
                case WHICH.SenderPromise:
                    SenderPromise = reader.SenderPromise;
                    break;
                case WHICH.ReceiverHosted:
                    ReceiverHosted = reader.ReceiverHosted;
                    break;
                case WHICH.ReceiverAnswer:
                    ReceiverAnswer = CapnpSerializable.Create<Capnp.Rpc.PromisedAnswer>(reader.ReceiverAnswer);
                    break;
                case WHICH.ThirdPartyHosted:
                    ThirdPartyHosted = CapnpSerializable.Create<Capnp.Rpc.ThirdPartyCapDescriptor>(reader.ThirdPartyHosted);
                    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.SenderHosted:
                        _content = 0;
                        break;
                    case WHICH.SenderPromise:
                        _content = 0;
                        break;
                    case WHICH.ReceiverHosted:
                        _content = 0;
                        break;
                    case WHICH.ReceiverAnswer:
                        _content = null;
                        break;
                    case WHICH.ThirdPartyHosted:
                        _content = null;
                        break;
                }
            }
        }

        public void serialize(WRITER writer)
        {
            writer.which = which;
            switch (which)
            {
                case WHICH.None:
                    break;
                case WHICH.SenderHosted:
                    writer.SenderHosted = SenderHosted!.Value;
                    break;
                case WHICH.SenderPromise:
                    writer.SenderPromise = SenderPromise!.Value;
                    break;
                case WHICH.ReceiverHosted:
                    writer.ReceiverHosted = ReceiverHosted!.Value;
                    break;
                case WHICH.ReceiverAnswer:
                    ReceiverAnswer?.serialize(writer.ReceiverAnswer!);
                    break;
                case WHICH.ThirdPartyHosted:
                    ThirdPartyHosted?.serialize(writer.ThirdPartyHosted!);
                    break;
            }
        }

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

        public void applyDefaults()
        {
        }

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

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

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

        public Capnp.Rpc.PromisedAnswer? ReceiverAnswer
        {
            get => _which == WHICH.ReceiverAnswer ? (Capnp.Rpc.PromisedAnswer?)_content : null;
            set
            {
                _which = WHICH.ReceiverAnswer;
                _content = value;
            }
        }

        public Capnp.Rpc.ThirdPartyCapDescriptor? ThirdPartyHosted
        {
            get => _which == WHICH.ThirdPartyHosted ? (Capnp.Rpc.ThirdPartyCapDescriptor?)_content : null;
            set
            {
                _which = WHICH.ThirdPartyHosted;
                _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 uint SenderHosted => which == WHICH.SenderHosted ? ctx.ReadDataUInt(32UL, 0U) : default;
            public uint SenderPromise => which == WHICH.SenderPromise ? ctx.ReadDataUInt(32UL, 0U) : default;
            public uint ReceiverHosted => which == WHICH.ReceiverHosted ? ctx.ReadDataUInt(32UL, 0U) : default;
            public Capnp.Rpc.PromisedAnswer.READER ReceiverAnswer => which == WHICH.ReceiverAnswer ? ctx.ReadStruct(0, Capnp.Rpc.PromisedAnswer.READER.create) : default;
            public Capnp.Rpc.ThirdPartyCapDescriptor.READER ThirdPartyHosted => which == WHICH.ThirdPartyHosted ? ctx.ReadStruct(0, Capnp.Rpc.ThirdPartyCapDescriptor.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 uint SenderHosted
            {
                get => which == WHICH.SenderHosted ? this.ReadDataUInt(32UL, 0U) : default;
                set => this.WriteData(32UL, value, 0U);
            }

            public uint SenderPromise
            {
                get => which == WHICH.SenderPromise ? this.ReadDataUInt(32UL, 0U) : default;
                set => this.WriteData(32UL, value, 0U);
            }

            public uint ReceiverHosted
            {
                get => which == WHICH.ReceiverHosted ? this.ReadDataUInt(32UL, 0U) : default;
                set => this.WriteData(32UL, value, 0U);
            }

            [DisallowNull]
            public Capnp.Rpc.PromisedAnswer.WRITER? ReceiverAnswer
            {
                get => which == WHICH.ReceiverAnswer ? BuildPointer<Capnp.Rpc.PromisedAnswer.WRITER>(0) : default;
                set => Link(0, value!);
            }

            [DisallowNull]
            public Capnp.Rpc.ThirdPartyCapDescriptor.WRITER? ThirdPartyHosted
            {
                get => which == WHICH.ThirdPartyHosted ? BuildPointer<Capnp.Rpc.ThirdPartyCapDescriptor.WRITER>(0) : default;
                set => Link(0, value!);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xd800b1d6cd6f1ca0UL)]
    public class PromisedAnswer : ICapnpSerializable
    {
        public const UInt64 typeId = 0xd800b1d6cd6f1ca0UL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            QuestionId = reader.QuestionId;
            Transform = reader.Transform?.ToReadOnlyList(_ => CapnpSerializable.Create<Capnp.Rpc.PromisedAnswer.Op>(_)!);
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.QuestionId = QuestionId;
            writer.Transform.Init(Transform, (_s1, _v1) => _v1?.serialize(_s1));
        }

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

        public void applyDefaults()
        {
        }

        public uint QuestionId
        {
            get;
            set;
        }

        public IReadOnlyList<Capnp.Rpc.PromisedAnswer.Op>? Transform
        {
            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 uint QuestionId => ctx.ReadDataUInt(0UL, 0U);
            public IReadOnlyList<Capnp.Rpc.PromisedAnswer.Op.READER> Transform => ctx.ReadList(0).Cast(Capnp.Rpc.PromisedAnswer.Op.READER.create);
        }

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

            public uint QuestionId
            {
                get => this.ReadDataUInt(0UL, 0U);
                set => this.WriteData(0UL, value, 0U);
            }

            public ListOfStructsSerializer<Capnp.Rpc.PromisedAnswer.Op.WRITER> Transform
            {
                get => BuildPointer<ListOfStructsSerializer<Capnp.Rpc.PromisedAnswer.Op.WRITER>>(0);
                set => Link(0, value);
            }
        }

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

            void ICapnpSerializable.Deserialize(DeserializerState arg_)
            {
                var reader = READER.create(arg_);
                switch (reader.which)
                {
                    case WHICH.Noop:
                        which = reader.which;
                        break;
                    case WHICH.GetPointerField:
                        GetPointerField = reader.GetPointerField;
                        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.Noop:
                            break;
                        case WHICH.GetPointerField:
                            _content = 0;
                            break;
                    }
                }
            }

            public void serialize(WRITER writer)
            {
                writer.which = which;
                switch (which)
                {
                    case WHICH.Noop:
                        break;
                    case WHICH.GetPointerField:
                        writer.GetPointerField = GetPointerField!.Value;
                        break;
                }
            }

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

            public void applyDefaults()
            {
            }

            public ushort? GetPointerField
            {
                get => _which == WHICH.GetPointerField ? (ushort?)_content : null;
                set
                {
                    _which = WHICH.GetPointerField;
                    _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 ushort GetPointerField => which == WHICH.GetPointerField ? ctx.ReadDataUShort(16UL, (ushort)0) : default;
            }

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

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

                public ushort GetPointerField
                {
                    get => which == WHICH.GetPointerField ? this.ReadDataUShort(16UL, (ushort)0) : default;
                    set => this.WriteData(16UL, value, (ushort)0);
                }
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xd37007fde1f0027dUL)]
    public class ThirdPartyCapDescriptor : ICapnpSerializable
    {
        public const UInt64 typeId = 0xd37007fde1f0027dUL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            Id = CapnpSerializable.Create<object>(reader.Id);
            VineId = reader.VineId;
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.Id.SetObject(Id);
            writer.VineId = VineId;
        }

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

        public void applyDefaults()
        {
        }

        public object? Id
        {
            get;
            set;
        }

        public uint VineId
        {
            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 DeserializerState Id => ctx.StructReadPointer(0);
            public uint VineId => ctx.ReadDataUInt(0UL, 0U);
        }

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

            public DynamicSerializerState Id
            {
                get => BuildPointer<DynamicSerializerState>(0);
                set => Link(0, value);
            }

            public uint VineId
            {
                get => this.ReadDataUInt(0UL, 0U);
                set => this.WriteData(0UL, value, 0U);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xd625b7063acf691aUL)]
    public class Exception : ICapnpSerializable
    {
        public const UInt64 typeId = 0xd625b7063acf691aUL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            Reason = reader.Reason;
            ObsoleteIsCallersFault = reader.ObsoleteIsCallersFault;
            ObsoleteDurability = reader.ObsoleteDurability;
            TheType = reader.TheType;
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.Reason = Reason;
            writer.ObsoleteIsCallersFault = ObsoleteIsCallersFault;
            writer.ObsoleteDurability = ObsoleteDurability;
            writer.TheType = TheType;
        }

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

        public void applyDefaults()
        {
        }

        public string? Reason
        {
            get;
            set;
        }

        public bool ObsoleteIsCallersFault
        {
            get;
            set;
        }

        public ushort ObsoleteDurability
        {
            get;
            set;
        }

        public Capnp.Rpc.Exception.Type TheType
        {
            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? Reason => ctx.ReadText(0, null);
            public bool ObsoleteIsCallersFault => ctx.ReadDataBool(0UL, false);
            public ushort ObsoleteDurability => ctx.ReadDataUShort(16UL, (ushort)0);
            public Capnp.Rpc.Exception.Type TheType => (Capnp.Rpc.Exception.Type)ctx.ReadDataUShort(32UL, (ushort)0);
        }

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

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

            public bool ObsoleteIsCallersFault
            {
                get => this.ReadDataBool(0UL, false);
                set => this.WriteData(0UL, value, false);
            }

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

            public Capnp.Rpc.Exception.Type TheType
            {
                get => (Capnp.Rpc.Exception.Type)this.ReadDataUShort(32UL, (ushort)0);
                set => this.WriteData(32UL, (ushort)value, (ushort)0);
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xb28c96e23f4cbd58UL)]
        public enum Type : ushort
        {
            failed,
            overloaded,
            disconnected,
            unimplemented
        }
    }
}