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(0x9d02dc8512eb28f7UL)]
    public class FabAccess : ICapnpSerializable
    {
        public const UInt64 typeId = 0x9d02dc8512eb28f7UL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            Permissions = reader.Permissions;
            Machines = reader.Machines;
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.Permissions = Permissions;
            writer.Machines = Machines;
        }

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

        public void applyDefaults()
        {
        }

        public CapnpGen.IPermissions Permissions
        {
            get;
            set;
        }

        public CapnpGen.IMachines Machines
        {
            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.IPermissions Permissions => ctx.ReadCap<CapnpGen.IPermissions>(0);
            public CapnpGen.IMachines Machines => ctx.ReadCap<CapnpGen.IMachines>(1);
        }

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

            public CapnpGen.IPermissions Permissions
            {
                get => ReadCap<CapnpGen.IPermissions>(0);
                set => LinkObject(0, value);
            }

            public CapnpGen.IMachines Machines
            {
                get => ReadCap<CapnpGen.IMachines>(1);
                set => LinkObject(1, value);
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa8056a3c7d638795UL), Proxy(typeof(Machines_Proxy)), Skeleton(typeof(Machines_Skeleton))]
    public interface IMachines : IDisposable
    {
        Task<IReadOnlyList<CapnpGen.Machine>> ListMachines(CancellationToken cancellationToken_ = default);
        Task<CapnpGen.Machine> GetMachine(CapnpGen.UUID uuid, CancellationToken cancellationToken_ = default);
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa8056a3c7d638795UL)]
    public class Machines_Proxy : Proxy, IMachines
    {
        public Task<IReadOnlyList<CapnpGen.Machine>> ListMachines(CancellationToken cancellationToken_ = default)
        {
            var in_ = SerializerState.CreateForRpc<CapnpGen.Machines.Params_ListMachines.WRITER>();
            var arg_ = new CapnpGen.Machines.Params_ListMachines()
            {};
            arg_?.serialize(in_);
            return Impatient.MakePipelineAware(Call(12107199981289703317UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
            {
                using (d_)
                {
                    var r_ = CapnpSerializable.Create<CapnpGen.Machines.Result_ListMachines>(d_);
                    return (r_.Machines);
                }
            }

            );
        }

        public Task<CapnpGen.Machine> GetMachine(CapnpGen.UUID uuid, CancellationToken cancellationToken_ = default)
        {
            var in_ = SerializerState.CreateForRpc<CapnpGen.Machines.Params_GetMachine.WRITER>();
            var arg_ = new CapnpGen.Machines.Params_GetMachine()
            {Uuid = uuid};
            arg_?.serialize(in_);
            return Impatient.MakePipelineAware(Call(12107199981289703317UL, 1, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
            {
                using (d_)
                {
                    var r_ = CapnpSerializable.Create<CapnpGen.Machines.Result_GetMachine>(d_);
                    return (r_.Machine);
                }
            }

            );
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa8056a3c7d638795UL)]
    public class Machines_Skeleton : Skeleton<IMachines>
    {
        public Machines_Skeleton()
        {
            SetMethodTable(ListMachines, GetMachine);
        }

        public override ulong InterfaceId => 12107199981289703317UL;
        Task<AnswerOrCounterquestion> ListMachines(DeserializerState d_, CancellationToken cancellationToken_)
        {
            using (d_)
            {
                return Impatient.MaybeTailCall(Impl.ListMachines(cancellationToken_), machines =>
                {
                    var s_ = SerializerState.CreateForRpc<CapnpGen.Machines.Result_ListMachines.WRITER>();
                    var r_ = new CapnpGen.Machines.Result_ListMachines{Machines = machines};
                    r_.serialize(s_);
                    return s_;
                }

                );
            }
        }

        Task<AnswerOrCounterquestion> GetMachine(DeserializerState d_, CancellationToken cancellationToken_)
        {
            using (d_)
            {
                var in_ = CapnpSerializable.Create<CapnpGen.Machines.Params_GetMachine>(d_);
                return Impatient.MaybeTailCall(Impl.GetMachine(in_.Uuid, cancellationToken_), machine =>
                {
                    var s_ = SerializerState.CreateForRpc<CapnpGen.Machines.Result_GetMachine.WRITER>();
                    var r_ = new CapnpGen.Machines.Result_GetMachine{Machine = machine};
                    r_.serialize(s_);
                    return s_;
                }

                );
            }
        }
    }

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

            public void serialize(WRITER writer)
            {
            }

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

            public void applyDefaults()
            {
            }

            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 class WRITER : SerializerState
            {
                public WRITER()
                {
                    this.SetStruct(0, 0);
                }
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xeb1a06e9fe8c21a7UL)]
        public class Result_ListMachines : ICapnpSerializable
        {
            public const UInt64 typeId = 0xeb1a06e9fe8c21a7UL;
            void ICapnpSerializable.Deserialize(DeserializerState arg_)
            {
                var reader = READER.create(arg_);
                Machines = reader.Machines?.ToReadOnlyList(_ => CapnpSerializable.Create<CapnpGen.Machine>(_));
                applyDefaults();
            }

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

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

            public void applyDefaults()
            {
            }

            public IReadOnlyList<CapnpGen.Machine> Machines
            {
                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 IReadOnlyList<CapnpGen.Machine.READER> Machines => ctx.ReadList(0).Cast(CapnpGen.Machine.READER.create);
            }

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

                public ListOfStructsSerializer<CapnpGen.Machine.WRITER> Machines
                {
                    get => BuildPointer<ListOfStructsSerializer<CapnpGen.Machine.WRITER>>(0);
                    set => Link(0, value);
                }
            }
        }

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

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

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

            public void applyDefaults()
            {
            }

            public CapnpGen.UUID Uuid
            {
                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.UUID.READER Uuid => ctx.ReadStruct(0, CapnpGen.UUID.READER.create);
            }

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

                public CapnpGen.UUID.WRITER Uuid
                {
                    get => BuildPointer<CapnpGen.UUID.WRITER>(0);
                    set => Link(0, value);
                }
            }
        }

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

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

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

            public void applyDefaults()
            {
            }

            public CapnpGen.Machine Machine
            {
                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.Machine.READER Machine => ctx.ReadStruct(0, CapnpGen.Machine.READER.create);
            }

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

                public CapnpGen.Machine.WRITER Machine
                {
                    get => BuildPointer<CapnpGen.Machine.WRITER>(0);
                    set => Link(0, value);
                }
            }
        }
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8bd7b57cda7ea5edUL), Proxy(typeof(Permissions_Proxy)), Skeleton(typeof(Permissions_Skeleton))]
    public interface IPermissions : IDisposable
    {
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8bd7b57cda7ea5edUL)]
    public class Permissions_Proxy : Proxy, IPermissions
    {
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8bd7b57cda7ea5edUL)]
    public class Permissions_Skeleton : Skeleton<IPermissions>
    {
        public Permissions_Skeleton()
        {
            SetMethodTable();
        }

        public override ulong InterfaceId => 10076722239111079405UL;
    }

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

        public void serialize(WRITER writer)
        {
            writer.Uuid0 = Uuid0;
            writer.Uuid1 = Uuid1;
        }

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

        public void applyDefaults()
        {
        }

        public ulong Uuid0
        {
            get;
            set;
        }

        public ulong Uuid1
        {
            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 ulong Uuid0 => ctx.ReadDataULong(0UL, 0UL);
            public ulong Uuid1 => ctx.ReadDataULong(64UL, 0UL);
        }

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

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

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

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xf6ba3aea4d4d16f1UL)]
    public enum State : ushort
    {
        free,
        inUse,
        toCheck,
        blocked,
        disabled,
        reserved
    }

    [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xe0941baa9afbf58bUL)]
    public class Machine : ICapnpSerializable
    {
        public const UInt64 typeId = 0xe0941baa9afbf58bUL;
        void ICapnpSerializable.Deserialize(DeserializerState arg_)
        {
            var reader = READER.create(arg_);
            Read = reader.Read;
            Write = reader.Write;
            Manage = reader.Manage;
            Getadmin = reader.Getadmin;
            applyDefaults();
        }

        public void serialize(WRITER writer)
        {
            writer.Read = Read;
            writer.Write = Write;
            writer.Manage = Manage;
            writer.Getadmin = Getadmin;
        }

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

        public void applyDefaults()
        {
        }

        public CapnpGen.Machine.IReadInterface Read
        {
            get;
            set;
        }

        public CapnpGen.Machine.IWriteInterface Write
        {
            get;
            set;
        }

        public CapnpGen.Machine.IManageInterface Manage
        {
            get;
            set;
        }

        public CapnpGen.Machine.IAdminInterface Getadmin
        {
            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.Machine.IReadInterface Read => ctx.ReadCap<CapnpGen.Machine.IReadInterface>(0);
            public CapnpGen.Machine.IWriteInterface Write => ctx.ReadCap<CapnpGen.Machine.IWriteInterface>(1);
            public CapnpGen.Machine.IManageInterface Manage => ctx.ReadCap<CapnpGen.Machine.IManageInterface>(2);
            public CapnpGen.Machine.IAdminInterface Getadmin => ctx.ReadCap<CapnpGen.Machine.IAdminInterface>(3);
        }

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

            public CapnpGen.Machine.IReadInterface Read
            {
                get => ReadCap<CapnpGen.Machine.IReadInterface>(0);
                set => LinkObject(0, value);
            }

            public CapnpGen.Machine.IWriteInterface Write
            {
                get => ReadCap<CapnpGen.Machine.IWriteInterface>(1);
                set => LinkObject(1, value);
            }

            public CapnpGen.Machine.IManageInterface Manage
            {
                get => ReadCap<CapnpGen.Machine.IManageInterface>(2);
                set => LinkObject(2, value);
            }

            public CapnpGen.Machine.IAdminInterface Getadmin
            {
                get => ReadCap<CapnpGen.Machine.IAdminInterface>(3);
                set => LinkObject(3, value);
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xf4a44636dfe61452UL)]
        public class MInfo : ICapnpSerializable
        {
            public const UInt64 typeId = 0xf4a44636dfe61452UL;
            void ICapnpSerializable.Deserialize(DeserializerState arg_)
            {
                var reader = READER.create(arg_);
                State = reader.State;
                Name = reader.Name;
                Description = reader.Description;
                Responsible = CapnpSerializable.Create<CapnpGen.User>(reader.Responsible);
                applyDefaults();
            }

            public void serialize(WRITER writer)
            {
                writer.State = State;
                writer.Name = Name;
                writer.Description = Description;
                Responsible?.serialize(writer.Responsible);
            }

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

            public void applyDefaults()
            {
            }

            public CapnpGen.State State
            {
                get;
                set;
            }

            public string Name
            {
                get;
                set;
            }

            public string Description
            {
                get;
                set;
            }

            public CapnpGen.User Responsible
            {
                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.State State => (CapnpGen.State)ctx.ReadDataUShort(0UL, (ushort)0);
                public string Name => ctx.ReadText(0, null);
                public string Description => ctx.ReadText(1, null);
                public CapnpGen.User.READER Responsible => ctx.ReadStruct(2, CapnpGen.User.READER.create);
            }

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

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

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

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

                public CapnpGen.User.WRITER Responsible
                {
                    get => BuildPointer<CapnpGen.User.WRITER>(2);
                    set => Link(2, value);
                }
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa33c86071ad4f9b3UL), Proxy(typeof(ReadInterface_Proxy)), Skeleton(typeof(ReadInterface_Skeleton))]
        public interface IReadInterface : IDisposable
        {
            Task<CapnpGen.Machine.MInfo> Info(CancellationToken cancellationToken_ = default);
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa33c86071ad4f9b3UL)]
        public class ReadInterface_Proxy : Proxy, IReadInterface
        {
            public Task<CapnpGen.Machine.MInfo> Info(CancellationToken cancellationToken_ = default)
            {
                var in_ = SerializerState.CreateForRpc<CapnpGen.Machine.ReadInterface.Params_Info.WRITER>();
                var arg_ = new CapnpGen.Machine.ReadInterface.Params_Info()
                {};
                arg_?.serialize(in_);
                return Impatient.MakePipelineAware(Call(11762423691857951155UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
                {
                    using (d_)
                    {
                        var r_ = CapnpSerializable.Create<CapnpGen.Machine.ReadInterface.Result_Info>(d_);
                        return (r_.Minfo);
                    }
                }

                );
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa33c86071ad4f9b3UL)]
        public class ReadInterface_Skeleton : Skeleton<IReadInterface>
        {
            public ReadInterface_Skeleton()
            {
                SetMethodTable(Info);
            }

            public override ulong InterfaceId => 11762423691857951155UL;
            Task<AnswerOrCounterquestion> Info(DeserializerState d_, CancellationToken cancellationToken_)
            {
                using (d_)
                {
                    return Impatient.MaybeTailCall(Impl.Info(cancellationToken_), minfo =>
                    {
                        var s_ = SerializerState.CreateForRpc<CapnpGen.Machine.ReadInterface.Result_Info.WRITER>();
                        var r_ = new CapnpGen.Machine.ReadInterface.Result_Info{Minfo = minfo};
                        r_.serialize(s_);
                        return s_;
                    }

                    );
                }
            }
        }

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

                public void serialize(WRITER writer)
                {
                }

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

                public void applyDefaults()
                {
                }

                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 class WRITER : SerializerState
                {
                    public WRITER()
                    {
                        this.SetStruct(0, 0);
                    }
                }
            }

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

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

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

                public void applyDefaults()
                {
                }

                public CapnpGen.Machine.MInfo Minfo
                {
                    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.Machine.MInfo.READER Minfo => ctx.ReadStruct(0, CapnpGen.Machine.MInfo.READER.create);
                }

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

                    public CapnpGen.Machine.MInfo.WRITER Minfo
                    {
                        get => BuildPointer<CapnpGen.Machine.MInfo.WRITER>(0);
                        set => Link(0, value);
                    }
                }
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xb6e2a9695eae285eUL), Proxy(typeof(WriteInterface_Proxy)), Skeleton(typeof(WriteInterface_Skeleton))]
        public interface IWriteInterface : IDisposable
        {
            Task<CapnpGen.Machine.WriteInterface.IGiveBack> Use(CancellationToken cancellationToken_ = default);
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xb6e2a9695eae285eUL)]
        public class WriteInterface_Proxy : Proxy, IWriteInterface
        {
            public Task<CapnpGen.Machine.WriteInterface.IGiveBack> Use(CancellationToken cancellationToken_ = default)
            {
                var in_ = SerializerState.CreateForRpc<CapnpGen.Machine.WriteInterface.Params_Use.WRITER>();
                var arg_ = new CapnpGen.Machine.WriteInterface.Params_Use()
                {};
                arg_?.serialize(in_);
                return Impatient.MakePipelineAware(Call(13178281729664624734UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_), d_ =>
                {
                    using (d_)
                    {
                        var r_ = CapnpSerializable.Create<CapnpGen.Machine.WriteInterface.Result_Use>(d_);
                        return (r_.Ret);
                    }
                }

                );
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xb6e2a9695eae285eUL)]
        public class WriteInterface_Skeleton : Skeleton<IWriteInterface>
        {
            public WriteInterface_Skeleton()
            {
                SetMethodTable(Use);
            }

            public override ulong InterfaceId => 13178281729664624734UL;
            Task<AnswerOrCounterquestion> Use(DeserializerState d_, CancellationToken cancellationToken_)
            {
                using (d_)
                {
                    return Impatient.MaybeTailCall(Impl.Use(cancellationToken_), ret =>
                    {
                        var s_ = SerializerState.CreateForRpc<CapnpGen.Machine.WriteInterface.Result_Use.WRITER>();
                        var r_ = new CapnpGen.Machine.WriteInterface.Result_Use{Ret = ret};
                        r_.serialize(s_);
                        return s_;
                    }

                    );
                }
            }
        }

        public static class WriteInterface
        {
            [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9e7723b44ddd390aUL), Proxy(typeof(GiveBack_Proxy)), Skeleton(typeof(GiveBack_Skeleton))]
            public interface IGiveBack : IDisposable
            {
                Task Ret(CancellationToken cancellationToken_ = default);
            }

            [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9e7723b44ddd390aUL)]
            public class GiveBack_Proxy : Proxy, IGiveBack
            {
                public async Task Ret(CancellationToken cancellationToken_ = default)
                {
                    var in_ = SerializerState.CreateForRpc<CapnpGen.Machine.WriteInterface.GiveBack.Params_Ret.WRITER>();
                    var arg_ = new CapnpGen.Machine.WriteInterface.GiveBack.Params_Ret()
                    {};
                    arg_?.serialize(in_);
                    using (var d_ = await Call(11418634637528611082UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
                    {
                        var r_ = CapnpSerializable.Create<CapnpGen.Machine.WriteInterface.GiveBack.Result_Ret>(d_);
                        return;
                    }
                }
            }

            [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x9e7723b44ddd390aUL)]
            public class GiveBack_Skeleton : Skeleton<IGiveBack>
            {
                public GiveBack_Skeleton()
                {
                    SetMethodTable(Ret);
                }

                public override ulong InterfaceId => 11418634637528611082UL;
                async Task<AnswerOrCounterquestion> Ret(DeserializerState d_, CancellationToken cancellationToken_)
                {
                    using (d_)
                    {
                        await Impl.Ret(cancellationToken_);
                        var s_ = SerializerState.CreateForRpc<CapnpGen.Machine.WriteInterface.GiveBack.Result_Ret.WRITER>();
                        return s_;
                    }
                }
            }

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

                    public void serialize(WRITER writer)
                    {
                    }

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

                    public void applyDefaults()
                    {
                    }

                    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 class WRITER : SerializerState
                    {
                        public WRITER()
                        {
                            this.SetStruct(0, 0);
                        }
                    }
                }

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

                    public void serialize(WRITER writer)
                    {
                    }

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

                    public void applyDefaults()
                    {
                    }

                    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 class WRITER : SerializerState
                    {
                        public WRITER()
                        {
                            this.SetStruct(0, 0);
                        }
                    }
                }
            }

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

                public void serialize(WRITER writer)
                {
                }

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

                public void applyDefaults()
                {
                }

                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 class WRITER : SerializerState
                {
                    public WRITER()
                    {
                        this.SetStruct(0, 0);
                    }
                }
            }

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

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

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

                public void applyDefaults()
                {
                }

                public CapnpGen.Machine.WriteInterface.IGiveBack Ret
                {
                    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.Machine.WriteInterface.IGiveBack Ret => ctx.ReadCap<CapnpGen.Machine.WriteInterface.IGiveBack>(0);
                }

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

                    public CapnpGen.Machine.WriteInterface.IGiveBack Ret
                    {
                        get => ReadCap<CapnpGen.Machine.WriteInterface.IGiveBack>(0);
                        set => LinkObject(0, value);
                    }
                }
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8549f91bdf2b5f6aUL), Proxy(typeof(ManageInterface_Proxy)), Skeleton(typeof(ManageInterface_Skeleton))]
        public interface IManageInterface : IDisposable
        {
            Task Ok(CancellationToken cancellationToken_ = default);
            Task NotOk(CancellationToken cancellationToken_ = default);
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8549f91bdf2b5f6aUL)]
        public class ManageInterface_Proxy : Proxy, IManageInterface
        {
            public async Task Ok(CancellationToken cancellationToken_ = default)
            {
                var in_ = SerializerState.CreateForRpc<CapnpGen.Machine.ManageInterface.Params_Ok.WRITER>();
                var arg_ = new CapnpGen.Machine.ManageInterface.Params_Ok()
                {};
                arg_?.serialize(in_);
                using (var d_ = await Call(9604481578447888234UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
                {
                    var r_ = CapnpSerializable.Create<CapnpGen.Machine.ManageInterface.Result_Ok>(d_);
                    return;
                }
            }

            public async Task NotOk(CancellationToken cancellationToken_ = default)
            {
                var in_ = SerializerState.CreateForRpc<CapnpGen.Machine.ManageInterface.Params_NotOk.WRITER>();
                var arg_ = new CapnpGen.Machine.ManageInterface.Params_NotOk()
                {};
                arg_?.serialize(in_);
                using (var d_ = await Call(9604481578447888234UL, 1, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
                {
                    var r_ = CapnpSerializable.Create<CapnpGen.Machine.ManageInterface.Result_NotOk>(d_);
                    return;
                }
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0x8549f91bdf2b5f6aUL)]
        public class ManageInterface_Skeleton : Skeleton<IManageInterface>
        {
            public ManageInterface_Skeleton()
            {
                SetMethodTable(Ok, NotOk);
            }

            public override ulong InterfaceId => 9604481578447888234UL;
            async Task<AnswerOrCounterquestion> Ok(DeserializerState d_, CancellationToken cancellationToken_)
            {
                using (d_)
                {
                    await Impl.Ok(cancellationToken_);
                    var s_ = SerializerState.CreateForRpc<CapnpGen.Machine.ManageInterface.Result_Ok.WRITER>();
                    return s_;
                }
            }

            async Task<AnswerOrCounterquestion> NotOk(DeserializerState d_, CancellationToken cancellationToken_)
            {
                using (d_)
                {
                    await Impl.NotOk(cancellationToken_);
                    var s_ = SerializerState.CreateForRpc<CapnpGen.Machine.ManageInterface.Result_NotOk.WRITER>();
                    return s_;
                }
            }
        }

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

                public void serialize(WRITER writer)
                {
                }

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

                public void applyDefaults()
                {
                }

                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 class WRITER : SerializerState
                {
                    public WRITER()
                    {
                        this.SetStruct(0, 0);
                    }
                }
            }

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

                public void serialize(WRITER writer)
                {
                }

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

                public void applyDefaults()
                {
                }

                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 class WRITER : SerializerState
                {
                    public WRITER()
                    {
                        this.SetStruct(0, 0);
                    }
                }
            }

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

                public void serialize(WRITER writer)
                {
                }

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

                public void applyDefaults()
                {
                }

                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 class WRITER : SerializerState
                {
                    public WRITER()
                    {
                        this.SetStruct(0, 0);
                    }
                }
            }

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

                public void serialize(WRITER writer)
                {
                }

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

                public void applyDefaults()
                {
                }

                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 class WRITER : SerializerState
                {
                    public WRITER()
                    {
                        this.SetStruct(0, 0);
                    }
                }
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa9ef75fc749739cfUL), Proxy(typeof(AdminInterface_Proxy)), Skeleton(typeof(AdminInterface_Skeleton))]
        public interface IAdminInterface : IDisposable
        {
            Task ForceSetState(CapnpGen.State state, CancellationToken cancellationToken_ = default);
            Task ForceSetUser(string user, CancellationToken cancellationToken_ = default);
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa9ef75fc749739cfUL)]
        public class AdminInterface_Proxy : Proxy, IAdminInterface
        {
            public async Task ForceSetState(CapnpGen.State state, CancellationToken cancellationToken_ = default)
            {
                var in_ = SerializerState.CreateForRpc<CapnpGen.Machine.AdminInterface.Params_ForceSetState.WRITER>();
                var arg_ = new CapnpGen.Machine.AdminInterface.Params_ForceSetState()
                {State = state};
                arg_?.serialize(in_);
                using (var d_ = await Call(12245135638991944143UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
                {
                    var r_ = CapnpSerializable.Create<CapnpGen.Machine.AdminInterface.Result_ForceSetState>(d_);
                    return;
                }
            }

            public async Task ForceSetUser(string user, CancellationToken cancellationToken_ = default)
            {
                var in_ = SerializerState.CreateForRpc<CapnpGen.Machine.AdminInterface.Params_ForceSetUser.WRITER>();
                var arg_ = new CapnpGen.Machine.AdminInterface.Params_ForceSetUser()
                {User = user};
                arg_?.serialize(in_);
                using (var d_ = await Call(12245135638991944143UL, 1, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
                {
                    var r_ = CapnpSerializable.Create<CapnpGen.Machine.AdminInterface.Result_ForceSetUser>(d_);
                    return;
                }
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xa9ef75fc749739cfUL)]
        public class AdminInterface_Skeleton : Skeleton<IAdminInterface>
        {
            public AdminInterface_Skeleton()
            {
                SetMethodTable(ForceSetState, ForceSetUser);
            }

            public override ulong InterfaceId => 12245135638991944143UL;
            async Task<AnswerOrCounterquestion> ForceSetState(DeserializerState d_, CancellationToken cancellationToken_)
            {
                using (d_)
                {
                    var in_ = CapnpSerializable.Create<CapnpGen.Machine.AdminInterface.Params_ForceSetState>(d_);
                    await Impl.ForceSetState(in_.State, cancellationToken_);
                    var s_ = SerializerState.CreateForRpc<CapnpGen.Machine.AdminInterface.Result_ForceSetState.WRITER>();
                    return s_;
                }
            }

            async Task<AnswerOrCounterquestion> ForceSetUser(DeserializerState d_, CancellationToken cancellationToken_)
            {
                using (d_)
                {
                    var in_ = CapnpSerializable.Create<CapnpGen.Machine.AdminInterface.Params_ForceSetUser>(d_);
                    await Impl.ForceSetUser(in_.User, cancellationToken_);
                    var s_ = SerializerState.CreateForRpc<CapnpGen.Machine.AdminInterface.Result_ForceSetUser.WRITER>();
                    return s_;
                }
            }
        }

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

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

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

                public void applyDefaults()
                {
                }

                public CapnpGen.State State
                {
                    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.State State => (CapnpGen.State)ctx.ReadDataUShort(0UL, (ushort)0);
                }

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

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

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

                public void serialize(WRITER writer)
                {
                }

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

                public void applyDefaults()
                {
                }

                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 class WRITER : SerializerState
                {
                    public WRITER()
                    {
                        this.SetStruct(0, 0);
                    }
                }
            }

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

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

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

                public void applyDefaults()
                {
                }

                public string User
                {
                    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 User => ctx.ReadText(0, null);
                }

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

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

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

                public void serialize(WRITER writer)
                {
                }

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

                public void applyDefaults()
                {
                }

                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 class WRITER : SerializerState
                {
                    public WRITER()
                    {
                        this.SetStruct(0, 0);
                    }
                }
            }
        }
    }

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

        public void serialize(WRITER writer)
        {
            writer.Read = Read;
            writer.Write = Write;
        }

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

        public void applyDefaults()
        {
        }

        public CapnpGen.User.IReadInterface Read
        {
            get;
            set;
        }

        public CapnpGen.User.IWriteInterface Write
        {
            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.User.IReadInterface Read => ctx.ReadCap<CapnpGen.User.IReadInterface>(0);
            public CapnpGen.User.IWriteInterface Write => ctx.ReadCap<CapnpGen.User.IWriteInterface>(1);
        }

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

            public CapnpGen.User.IReadInterface Read
            {
                get => ReadCap<CapnpGen.User.IReadInterface>(0);
                set => LinkObject(0, value);
            }

            public CapnpGen.User.IWriteInterface Write
            {
                get => ReadCap<CapnpGen.User.IWriteInterface>(1);
                set => LinkObject(1, value);
            }
        }

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

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

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

            public void applyDefaults()
            {
            }

            public string Id
            {
                get;
                set;
            }

            public string Name
            {
                get;
                set;
            }

            public string OriginatingWorkshop
            {
                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 Id => ctx.ReadText(0, null);
                public string Name => ctx.ReadText(1, null);
                public string OriginatingWorkshop => ctx.ReadText(2, null);
            }

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

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

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

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

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xe2dfdbce3f04d040UL), Proxy(typeof(ReadInterface_Proxy)), Skeleton(typeof(ReadInterface_Skeleton))]
        public interface IReadInterface : IDisposable
        {
            Task<CapnpGen.User.UserInformation> Info(CancellationToken cancellationToken_ = default);
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xe2dfdbce3f04d040UL)]
        public class ReadInterface_Proxy : Proxy, IReadInterface
        {
            public async Task<CapnpGen.User.UserInformation> Info(CancellationToken cancellationToken_ = default)
            {
                var in_ = SerializerState.CreateForRpc<CapnpGen.User.ReadInterface.Params_Info.WRITER>();
                var arg_ = new CapnpGen.User.ReadInterface.Params_Info()
                {};
                arg_?.serialize(in_);
                using (var d_ = await Call(16348026851245215808UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
                {
                    var r_ = CapnpSerializable.Create<CapnpGen.User.ReadInterface.Result_Info>(d_);
                    return (r_.Uinfo);
                }
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xe2dfdbce3f04d040UL)]
        public class ReadInterface_Skeleton : Skeleton<IReadInterface>
        {
            public ReadInterface_Skeleton()
            {
                SetMethodTable(Info);
            }

            public override ulong InterfaceId => 16348026851245215808UL;
            Task<AnswerOrCounterquestion> Info(DeserializerState d_, CancellationToken cancellationToken_)
            {
                using (d_)
                {
                    return Impatient.MaybeTailCall(Impl.Info(cancellationToken_), uinfo =>
                    {
                        var s_ = SerializerState.CreateForRpc<CapnpGen.User.ReadInterface.Result_Info.WRITER>();
                        var r_ = new CapnpGen.User.ReadInterface.Result_Info{Uinfo = uinfo};
                        r_.serialize(s_);
                        return s_;
                    }

                    );
                }
            }
        }

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

                public void serialize(WRITER writer)
                {
                }

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

                public void applyDefaults()
                {
                }

                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 class WRITER : SerializerState
                {
                    public WRITER()
                    {
                        this.SetStruct(0, 0);
                    }
                }
            }

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

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

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

                public void applyDefaults()
                {
                }

                public CapnpGen.User.UserInformation Uinfo
                {
                    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.User.UserInformation.READER Uinfo => ctx.ReadStruct(0, CapnpGen.User.UserInformation.READER.create);
                }

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

                    public CapnpGen.User.UserInformation.WRITER Uinfo
                    {
                        get => BuildPointer<CapnpGen.User.UserInformation.WRITER>(0);
                        set => Link(0, value);
                    }
                }
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xc40808cb71bd6054UL), Proxy(typeof(WriteInterface_Proxy)), Skeleton(typeof(WriteInterface_Skeleton))]
        public interface IWriteInterface : IDisposable
        {
            Task SetName(string name, CancellationToken cancellationToken_ = default);
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xc40808cb71bd6054UL)]
        public class WriteInterface_Proxy : Proxy, IWriteInterface
        {
            public async Task SetName(string name, CancellationToken cancellationToken_ = default)
            {
                var in_ = SerializerState.CreateForRpc<CapnpGen.User.WriteInterface.Params_SetName.WRITER>();
                var arg_ = new CapnpGen.User.WriteInterface.Params_SetName()
                {Name = name};
                arg_?.serialize(in_);
                using (var d_ = await Call(14125549901127180372UL, 0, in_.Rewrap<DynamicSerializerState>(), false, cancellationToken_).WhenReturned)
                {
                    var r_ = CapnpSerializable.Create<CapnpGen.User.WriteInterface.Result_SetName>(d_);
                    return;
                }
            }
        }

        [System.CodeDom.Compiler.GeneratedCode("capnpc-csharp", "1.3.0.0"), TypeId(0xc40808cb71bd6054UL)]
        public class WriteInterface_Skeleton : Skeleton<IWriteInterface>
        {
            public WriteInterface_Skeleton()
            {
                SetMethodTable(SetName);
            }

            public override ulong InterfaceId => 14125549901127180372UL;
            async Task<AnswerOrCounterquestion> SetName(DeserializerState d_, CancellationToken cancellationToken_)
            {
                using (d_)
                {
                    var in_ = CapnpSerializable.Create<CapnpGen.User.WriteInterface.Params_SetName>(d_);
                    await Impl.SetName(in_.Name, cancellationToken_);
                    var s_ = SerializerState.CreateForRpc<CapnpGen.User.WriteInterface.Result_SetName.WRITER>();
                    return s_;
                }
            }
        }

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

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

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

                public void applyDefaults()
                {
                }

                public string Name
                {
                    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 Name => ctx.ReadText(0, null);
                }

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

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

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

                public void serialize(WRITER writer)
                {
                }

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

                public void applyDefaults()
                {
                }

                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 class WRITER : SerializerState
                {
                    public WRITER()
                    {
                        this.SetStruct(0, 0);
                    }
                }
            }
        }
    }

    public static partial class PipeliningSupportExtensions_api
    {
        static readonly MemberAccessPath Path__Machines_getMachine_Machine_Getadmin = new MemberAccessPath(0U, 3U);
        public static CapnpGen.Machine.IAdminInterface Machine_Getadmin(this Task<CapnpGen.Machine> task)
        {
            async Task<IDisposable> AwaitProxy() => (await task).Machine?.Getadmin;
            return (CapnpGen.Machine.IAdminInterface)CapabilityReflection.CreateProxy<CapnpGen.Machine.IAdminInterface>(Impatient.Access(task, Path__Machines_getMachine_Machine_Getadmin, AwaitProxy()));
        }

        static readonly MemberAccessPath Path__Machines_getMachine_Machine_Manage = new MemberAccessPath(0U, 2U);
        public static CapnpGen.Machine.IManageInterface Machine_Manage(this Task<CapnpGen.Machine> task)
        {
            async Task<IDisposable> AwaitProxy() => (await task).Machine?.Manage;
            return (CapnpGen.Machine.IManageInterface)CapabilityReflection.CreateProxy<CapnpGen.Machine.IManageInterface>(Impatient.Access(task, Path__Machines_getMachine_Machine_Manage, AwaitProxy()));
        }

        static readonly MemberAccessPath Path__Machines_getMachine_Machine_Write = new MemberAccessPath(0U, 1U);
        public static CapnpGen.Machine.IWriteInterface Machine_Write(this Task<CapnpGen.Machine> task)
        {
            async Task<IDisposable> AwaitProxy() => (await task).Machine?.Write;
            return (CapnpGen.Machine.IWriteInterface)CapabilityReflection.CreateProxy<CapnpGen.Machine.IWriteInterface>(Impatient.Access(task, Path__Machines_getMachine_Machine_Write, AwaitProxy()));
        }

        static readonly MemberAccessPath Path__Machines_getMachine_Machine_Read = new MemberAccessPath(0U, 0U);
        public static CapnpGen.Machine.IReadInterface Machine_Read(this Task<CapnpGen.Machine> task)
        {
            async Task<IDisposable> AwaitProxy() => (await task).Machine?.Read;
            return (CapnpGen.Machine.IReadInterface)CapabilityReflection.CreateProxy<CapnpGen.Machine.IReadInterface>(Impatient.Access(task, Path__Machines_getMachine_Machine_Read, AwaitProxy()));
        }

        static readonly MemberAccessPath Path_Machine_Read_info_Minfo_Responsible_Write = new MemberAccessPath(0U, 2U, 1U);
        public static CapnpGen.User.IWriteInterface Minfo_Responsible_Write(this Task<CapnpGen.Machine.MInfo> task)
        {
            async Task<IDisposable> AwaitProxy() => (await task).Minfo?.Responsible?.Write;
            return (CapnpGen.User.IWriteInterface)CapabilityReflection.CreateProxy<CapnpGen.User.IWriteInterface>(Impatient.Access(task, Path_Machine_Read_info_Minfo_Responsible_Write, AwaitProxy()));
        }

        static readonly MemberAccessPath Path_Machine_Read_info_Minfo_Responsible_Read = new MemberAccessPath(0U, 2U, 0U);
        public static CapnpGen.User.IReadInterface Minfo_Responsible_Read(this Task<CapnpGen.Machine.MInfo> task)
        {
            async Task<IDisposable> AwaitProxy() => (await task).Minfo?.Responsible?.Read;
            return (CapnpGen.User.IReadInterface)CapabilityReflection.CreateProxy<CapnpGen.User.IReadInterface>(Impatient.Access(task, Path_Machine_Read_info_Minfo_Responsible_Read, AwaitProxy()));
        }
    }
}