// Code generated by capnpc-go. DO NOT EDIT. package tunnelrpc import ( context "golang.org/x/net/context" capnp "zombiezen.com/go/capnproto2" text "zombiezen.com/go/capnproto2/encoding/text" schemas "zombiezen.com/go/capnproto2/schemas" server "zombiezen.com/go/capnproto2/server" ) type Authentication struct{ capnp.Struct } // Authentication_TypeID is the unique identifier for the type Authentication. const Authentication_TypeID = 0xc082ef6e0d42ed1d func NewAuthentication(s *capnp.Segment) (Authentication, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}) return Authentication{st}, err } func NewRootAuthentication(s *capnp.Segment) (Authentication, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}) return Authentication{st}, err } func ReadRootAuthentication(msg *capnp.Message) (Authentication, error) { root, err := msg.RootPtr() return Authentication{root.Struct()}, err } func (s Authentication) String() string { str, _ := text.Marshal(0xc082ef6e0d42ed1d, s.Struct) return str } func (s Authentication) Key() (string, error) { p, err := s.Struct.Ptr(0) return p.Text(), err } func (s Authentication) HasKey() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s Authentication) KeyBytes() ([]byte, error) { p, err := s.Struct.Ptr(0) return p.TextBytes(), err } func (s Authentication) SetKey(v string) error { return s.Struct.SetText(0, v) } func (s Authentication) Email() (string, error) { p, err := s.Struct.Ptr(1) return p.Text(), err } func (s Authentication) HasEmail() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s Authentication) EmailBytes() ([]byte, error) { p, err := s.Struct.Ptr(1) return p.TextBytes(), err } func (s Authentication) SetEmail(v string) error { return s.Struct.SetText(1, v) } func (s Authentication) OriginCAKey() (string, error) { p, err := s.Struct.Ptr(2) return p.Text(), err } func (s Authentication) HasOriginCAKey() bool { p, err := s.Struct.Ptr(2) return p.IsValid() || err != nil } func (s Authentication) OriginCAKeyBytes() ([]byte, error) { p, err := s.Struct.Ptr(2) return p.TextBytes(), err } func (s Authentication) SetOriginCAKey(v string) error { return s.Struct.SetText(2, v) } // Authentication_List is a list of Authentication. type Authentication_List struct{ capnp.List } // NewAuthentication creates a new list of Authentication. func NewAuthentication_List(s *capnp.Segment, sz int32) (Authentication_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz) return Authentication_List{l}, err } func (s Authentication_List) At(i int) Authentication { return Authentication{s.List.Struct(i)} } func (s Authentication_List) Set(i int, v Authentication) error { return s.List.SetStruct(i, v.Struct) } // Authentication_Promise is a wrapper for a Authentication promised by a client call. type Authentication_Promise struct{ *capnp.Pipeline } func (p Authentication_Promise) Struct() (Authentication, error) { s, err := p.Pipeline.Struct() return Authentication{s}, err } type TunnelRegistration struct{ capnp.Struct } // TunnelRegistration_TypeID is the unique identifier for the type TunnelRegistration. const TunnelRegistration_TypeID = 0xf41a0f001ad49e46 func NewTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}) return TunnelRegistration{st}, err } func NewRootTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}) return TunnelRegistration{st}, err } func ReadRootTunnelRegistration(msg *capnp.Message) (TunnelRegistration, error) { root, err := msg.RootPtr() return TunnelRegistration{root.Struct()}, err } func (s TunnelRegistration) String() string { str, _ := text.Marshal(0xf41a0f001ad49e46, s.Struct) return str } func (s TunnelRegistration) Err() (string, error) { p, err := s.Struct.Ptr(0) return p.Text(), err } func (s TunnelRegistration) HasErr() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s TunnelRegistration) ErrBytes() ([]byte, error) { p, err := s.Struct.Ptr(0) return p.TextBytes(), err } func (s TunnelRegistration) SetErr(v string) error { return s.Struct.SetText(0, v) } func (s TunnelRegistration) Url() (string, error) { p, err := s.Struct.Ptr(1) return p.Text(), err } func (s TunnelRegistration) HasUrl() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s TunnelRegistration) UrlBytes() ([]byte, error) { p, err := s.Struct.Ptr(1) return p.TextBytes(), err } func (s TunnelRegistration) SetUrl(v string) error { return s.Struct.SetText(1, v) } func (s TunnelRegistration) LogLines() (capnp.TextList, error) { p, err := s.Struct.Ptr(2) return capnp.TextList{List: p.List()}, err } func (s TunnelRegistration) HasLogLines() bool { p, err := s.Struct.Ptr(2) return p.IsValid() || err != nil } func (s TunnelRegistration) SetLogLines(v capnp.TextList) error { return s.Struct.SetPtr(2, v.List.ToPtr()) } // NewLogLines sets the logLines field to a newly // allocated capnp.TextList, preferring placement in s's segment. func (s TunnelRegistration) NewLogLines(n int32) (capnp.TextList, error) { l, err := capnp.NewTextList(s.Struct.Segment(), n) if err != nil { return capnp.TextList{}, err } err = s.Struct.SetPtr(2, l.List.ToPtr()) return l, err } func (s TunnelRegistration) PermanentFailure() bool { return s.Struct.Bit(0) } func (s TunnelRegistration) SetPermanentFailure(v bool) { s.Struct.SetBit(0, v) } func (s TunnelRegistration) TunnelID() (string, error) { p, err := s.Struct.Ptr(3) return p.Text(), err } func (s TunnelRegistration) HasTunnelID() bool { p, err := s.Struct.Ptr(3) return p.IsValid() || err != nil } func (s TunnelRegistration) TunnelIDBytes() ([]byte, error) { p, err := s.Struct.Ptr(3) return p.TextBytes(), err } func (s TunnelRegistration) SetTunnelID(v string) error { return s.Struct.SetText(3, v) } // TunnelRegistration_List is a list of TunnelRegistration. type TunnelRegistration_List struct{ capnp.List } // NewTunnelRegistration creates a new list of TunnelRegistration. func NewTunnelRegistration_List(s *capnp.Segment, sz int32) (TunnelRegistration_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}, sz) return TunnelRegistration_List{l}, err } func (s TunnelRegistration_List) At(i int) TunnelRegistration { return TunnelRegistration{s.List.Struct(i)} } func (s TunnelRegistration_List) Set(i int, v TunnelRegistration) error { return s.List.SetStruct(i, v.Struct) } // TunnelRegistration_Promise is a wrapper for a TunnelRegistration promised by a client call. type TunnelRegistration_Promise struct{ *capnp.Pipeline } func (p TunnelRegistration_Promise) Struct() (TunnelRegistration, error) { s, err := p.Pipeline.Struct() return TunnelRegistration{s}, err } type RegistrationOptions struct{ capnp.Struct } // RegistrationOptions_TypeID is the unique identifier for the type RegistrationOptions. const RegistrationOptions_TypeID = 0xc793e50592935b4a func NewRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 6}) return RegistrationOptions{st}, err } func NewRootRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 6}) return RegistrationOptions{st}, err } func ReadRootRegistrationOptions(msg *capnp.Message) (RegistrationOptions, error) { root, err := msg.RootPtr() return RegistrationOptions{root.Struct()}, err } func (s RegistrationOptions) String() string { str, _ := text.Marshal(0xc793e50592935b4a, s.Struct) return str } func (s RegistrationOptions) ClientId() (string, error) { p, err := s.Struct.Ptr(0) return p.Text(), err } func (s RegistrationOptions) HasClientId() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s RegistrationOptions) ClientIdBytes() ([]byte, error) { p, err := s.Struct.Ptr(0) return p.TextBytes(), err } func (s RegistrationOptions) SetClientId(v string) error { return s.Struct.SetText(0, v) } func (s RegistrationOptions) Version() (string, error) { p, err := s.Struct.Ptr(1) return p.Text(), err } func (s RegistrationOptions) HasVersion() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s RegistrationOptions) VersionBytes() ([]byte, error) { p, err := s.Struct.Ptr(1) return p.TextBytes(), err } func (s RegistrationOptions) SetVersion(v string) error { return s.Struct.SetText(1, v) } func (s RegistrationOptions) Os() (string, error) { p, err := s.Struct.Ptr(2) return p.Text(), err } func (s RegistrationOptions) HasOs() bool { p, err := s.Struct.Ptr(2) return p.IsValid() || err != nil } func (s RegistrationOptions) OsBytes() ([]byte, error) { p, err := s.Struct.Ptr(2) return p.TextBytes(), err } func (s RegistrationOptions) SetOs(v string) error { return s.Struct.SetText(2, v) } func (s RegistrationOptions) ExistingTunnelPolicy() ExistingTunnelPolicy { return ExistingTunnelPolicy(s.Struct.Uint16(0)) } func (s RegistrationOptions) SetExistingTunnelPolicy(v ExistingTunnelPolicy) { s.Struct.SetUint16(0, uint16(v)) } func (s RegistrationOptions) PoolName() (string, error) { p, err := s.Struct.Ptr(3) return p.Text(), err } func (s RegistrationOptions) HasPoolName() bool { p, err := s.Struct.Ptr(3) return p.IsValid() || err != nil } func (s RegistrationOptions) PoolNameBytes() ([]byte, error) { p, err := s.Struct.Ptr(3) return p.TextBytes(), err } func (s RegistrationOptions) SetPoolName(v string) error { return s.Struct.SetText(3, v) } func (s RegistrationOptions) Tags() (Tag_List, error) { p, err := s.Struct.Ptr(4) return Tag_List{List: p.List()}, err } func (s RegistrationOptions) HasTags() bool { p, err := s.Struct.Ptr(4) return p.IsValid() || err != nil } func (s RegistrationOptions) SetTags(v Tag_List) error { return s.Struct.SetPtr(4, v.List.ToPtr()) } // NewTags sets the tags field to a newly // allocated Tag_List, preferring placement in s's segment. func (s RegistrationOptions) NewTags(n int32) (Tag_List, error) { l, err := NewTag_List(s.Struct.Segment(), n) if err != nil { return Tag_List{}, err } err = s.Struct.SetPtr(4, l.List.ToPtr()) return l, err } func (s RegistrationOptions) ConnectionId() uint8 { return s.Struct.Uint8(2) } func (s RegistrationOptions) SetConnectionId(v uint8) { s.Struct.SetUint8(2, v) } func (s RegistrationOptions) OriginLocalIp() (string, error) { p, err := s.Struct.Ptr(5) return p.Text(), err } func (s RegistrationOptions) HasOriginLocalIp() bool { p, err := s.Struct.Ptr(5) return p.IsValid() || err != nil } func (s RegistrationOptions) OriginLocalIpBytes() ([]byte, error) { p, err := s.Struct.Ptr(5) return p.TextBytes(), err } func (s RegistrationOptions) SetOriginLocalIp(v string) error { return s.Struct.SetText(5, v) } func (s RegistrationOptions) IsAutoupdated() bool { return s.Struct.Bit(24) } func (s RegistrationOptions) SetIsAutoupdated(v bool) { s.Struct.SetBit(24, v) } func (s RegistrationOptions) RunFromTerminal() bool { return s.Struct.Bit(25) } func (s RegistrationOptions) SetRunFromTerminal(v bool) { s.Struct.SetBit(25, v) } func (s RegistrationOptions) CompressionQuality() uint64 { return s.Struct.Uint64(8) } func (s RegistrationOptions) SetCompressionQuality(v uint64) { s.Struct.SetUint64(8, v) } // RegistrationOptions_List is a list of RegistrationOptions. type RegistrationOptions_List struct{ capnp.List } // NewRegistrationOptions creates a new list of RegistrationOptions. func NewRegistrationOptions_List(s *capnp.Segment, sz int32) (RegistrationOptions_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 6}, sz) return RegistrationOptions_List{l}, err } func (s RegistrationOptions_List) At(i int) RegistrationOptions { return RegistrationOptions{s.List.Struct(i)} } func (s RegistrationOptions_List) Set(i int, v RegistrationOptions) error { return s.List.SetStruct(i, v.Struct) } // RegistrationOptions_Promise is a wrapper for a RegistrationOptions promised by a client call. type RegistrationOptions_Promise struct{ *capnp.Pipeline } func (p RegistrationOptions_Promise) Struct() (RegistrationOptions, error) { s, err := p.Pipeline.Struct() return RegistrationOptions{s}, err } type Tag struct{ capnp.Struct } // Tag_TypeID is the unique identifier for the type Tag. const Tag_TypeID = 0xcbd96442ae3bb01a func NewTag(s *capnp.Segment) (Tag, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}) return Tag{st}, err } func NewRootTag(s *capnp.Segment) (Tag, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}) return Tag{st}, err } func ReadRootTag(msg *capnp.Message) (Tag, error) { root, err := msg.RootPtr() return Tag{root.Struct()}, err } func (s Tag) String() string { str, _ := text.Marshal(0xcbd96442ae3bb01a, s.Struct) return str } func (s Tag) Name() (string, error) { p, err := s.Struct.Ptr(0) return p.Text(), err } func (s Tag) HasName() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s Tag) NameBytes() ([]byte, error) { p, err := s.Struct.Ptr(0) return p.TextBytes(), err } func (s Tag) SetName(v string) error { return s.Struct.SetText(0, v) } func (s Tag) Value() (string, error) { p, err := s.Struct.Ptr(1) return p.Text(), err } func (s Tag) HasValue() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s Tag) ValueBytes() ([]byte, error) { p, err := s.Struct.Ptr(1) return p.TextBytes(), err } func (s Tag) SetValue(v string) error { return s.Struct.SetText(1, v) } // Tag_List is a list of Tag. type Tag_List struct{ capnp.List } // NewTag creates a new list of Tag. func NewTag_List(s *capnp.Segment, sz int32) (Tag_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz) return Tag_List{l}, err } func (s Tag_List) At(i int) Tag { return Tag{s.List.Struct(i)} } func (s Tag_List) Set(i int, v Tag) error { return s.List.SetStruct(i, v.Struct) } // Tag_Promise is a wrapper for a Tag promised by a client call. type Tag_Promise struct{ *capnp.Pipeline } func (p Tag_Promise) Struct() (Tag, error) { s, err := p.Pipeline.Struct() return Tag{s}, err } type ExistingTunnelPolicy uint16 // ExistingTunnelPolicy_TypeID is the unique identifier for the type ExistingTunnelPolicy. const ExistingTunnelPolicy_TypeID = 0x84cb9536a2cf6d3c // Values of ExistingTunnelPolicy. const ( ExistingTunnelPolicy_ignore ExistingTunnelPolicy = 0 ExistingTunnelPolicy_disconnect ExistingTunnelPolicy = 1 ExistingTunnelPolicy_balance ExistingTunnelPolicy = 2 ) // String returns the enum's constant name. func (c ExistingTunnelPolicy) String() string { switch c { case ExistingTunnelPolicy_ignore: return "ignore" case ExistingTunnelPolicy_disconnect: return "disconnect" case ExistingTunnelPolicy_balance: return "balance" default: return "" } } // ExistingTunnelPolicyFromString returns the enum value with a name, // or the zero value if there's no such value. func ExistingTunnelPolicyFromString(c string) ExistingTunnelPolicy { switch c { case "ignore": return ExistingTunnelPolicy_ignore case "disconnect": return ExistingTunnelPolicy_disconnect case "balance": return ExistingTunnelPolicy_balance default: return 0 } } type ExistingTunnelPolicy_List struct{ capnp.List } func NewExistingTunnelPolicy_List(s *capnp.Segment, sz int32) (ExistingTunnelPolicy_List, error) { l, err := capnp.NewUInt16List(s, sz) return ExistingTunnelPolicy_List{l.List}, err } func (l ExistingTunnelPolicy_List) At(i int) ExistingTunnelPolicy { ul := capnp.UInt16List{List: l.List} return ExistingTunnelPolicy(ul.At(i)) } func (l ExistingTunnelPolicy_List) Set(i int, v ExistingTunnelPolicy) { ul := capnp.UInt16List{List: l.List} ul.Set(i, uint16(v)) } type ServerInfo struct{ capnp.Struct } // ServerInfo_TypeID is the unique identifier for the type ServerInfo. const ServerInfo_TypeID = 0xf2c68e2547ec3866 func NewServerInfo(s *capnp.Segment) (ServerInfo, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return ServerInfo{st}, err } func NewRootServerInfo(s *capnp.Segment) (ServerInfo, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return ServerInfo{st}, err } func ReadRootServerInfo(msg *capnp.Message) (ServerInfo, error) { root, err := msg.RootPtr() return ServerInfo{root.Struct()}, err } func (s ServerInfo) String() string { str, _ := text.Marshal(0xf2c68e2547ec3866, s.Struct) return str } func (s ServerInfo) LocationName() (string, error) { p, err := s.Struct.Ptr(0) return p.Text(), err } func (s ServerInfo) HasLocationName() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s ServerInfo) LocationNameBytes() ([]byte, error) { p, err := s.Struct.Ptr(0) return p.TextBytes(), err } func (s ServerInfo) SetLocationName(v string) error { return s.Struct.SetText(0, v) } // ServerInfo_List is a list of ServerInfo. type ServerInfo_List struct{ capnp.List } // NewServerInfo creates a new list of ServerInfo. func NewServerInfo_List(s *capnp.Segment, sz int32) (ServerInfo_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) return ServerInfo_List{l}, err } func (s ServerInfo_List) At(i int) ServerInfo { return ServerInfo{s.List.Struct(i)} } func (s ServerInfo_List) Set(i int, v ServerInfo) error { return s.List.SetStruct(i, v.Struct) } // ServerInfo_Promise is a wrapper for a ServerInfo promised by a client call. type ServerInfo_Promise struct{ *capnp.Pipeline } func (p ServerInfo_Promise) Struct() (ServerInfo, error) { s, err := p.Pipeline.Struct() return ServerInfo{s}, err } type TunnelServer struct{ Client capnp.Client } // TunnelServer_TypeID is the unique identifier for the type TunnelServer. const TunnelServer_TypeID = 0xea58385c65416035 func (c TunnelServer) RegisterTunnel(ctx context.Context, params func(TunnelServer_registerTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_registerTunnel_Results_Promise { if c.Client == nil { return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))} } call := &capnp.Call{ Ctx: ctx, Method: capnp.Method{ InterfaceID: 0xea58385c65416035, MethodID: 0, InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer", MethodName: "registerTunnel", }, Options: capnp.NewCallOptions(opts), } if params != nil { call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 3} call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_registerTunnel_Params{Struct: s}) } } return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))} } func (c TunnelServer) GetServerInfo(ctx context.Context, params func(TunnelServer_getServerInfo_Params) error, opts ...capnp.CallOption) TunnelServer_getServerInfo_Results_Promise { if c.Client == nil { return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))} } call := &capnp.Call{ Ctx: ctx, Method: capnp.Method{ InterfaceID: 0xea58385c65416035, MethodID: 1, InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer", MethodName: "getServerInfo", }, Options: capnp.NewCallOptions(opts), } if params != nil { call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0} call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_getServerInfo_Params{Struct: s}) } } return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))} } func (c TunnelServer) UnregisterTunnel(ctx context.Context, params func(TunnelServer_unregisterTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_unregisterTunnel_Results_Promise { if c.Client == nil { return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))} } call := &capnp.Call{ Ctx: ctx, Method: capnp.Method{ InterfaceID: 0xea58385c65416035, MethodID: 2, InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer", MethodName: "unregisterTunnel", }, Options: capnp.NewCallOptions(opts), } if params != nil { call.ParamsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 0} call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_unregisterTunnel_Params{Struct: s}) } } return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))} } type TunnelServer_Server interface { RegisterTunnel(TunnelServer_registerTunnel) error GetServerInfo(TunnelServer_getServerInfo) error UnregisterTunnel(TunnelServer_unregisterTunnel) error } func TunnelServer_ServerToClient(s TunnelServer_Server) TunnelServer { c, _ := s.(server.Closer) return TunnelServer{Client: server.New(TunnelServer_Methods(nil, s), c)} } func TunnelServer_Methods(methods []server.Method, s TunnelServer_Server) []server.Method { if cap(methods) == 0 { methods = make([]server.Method, 0, 3) } methods = append(methods, server.Method{ Method: capnp.Method{ InterfaceID: 0xea58385c65416035, MethodID: 0, InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer", MethodName: "registerTunnel", }, Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error { call := TunnelServer_registerTunnel{c, opts, TunnelServer_registerTunnel_Params{Struct: p}, TunnelServer_registerTunnel_Results{Struct: r}} return s.RegisterTunnel(call) }, ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1}, }) methods = append(methods, server.Method{ Method: capnp.Method{ InterfaceID: 0xea58385c65416035, MethodID: 1, InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer", MethodName: "getServerInfo", }, Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error { call := TunnelServer_getServerInfo{c, opts, TunnelServer_getServerInfo_Params{Struct: p}, TunnelServer_getServerInfo_Results{Struct: r}} return s.GetServerInfo(call) }, ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1}, }) methods = append(methods, server.Method{ Method: capnp.Method{ InterfaceID: 0xea58385c65416035, MethodID: 2, InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer", MethodName: "unregisterTunnel", }, Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error { call := TunnelServer_unregisterTunnel{c, opts, TunnelServer_unregisterTunnel_Params{Struct: p}, TunnelServer_unregisterTunnel_Results{Struct: r}} return s.UnregisterTunnel(call) }, ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0}, }) return methods } // TunnelServer_registerTunnel holds the arguments for a server call to TunnelServer.registerTunnel. type TunnelServer_registerTunnel struct { Ctx context.Context Options capnp.CallOptions Params TunnelServer_registerTunnel_Params Results TunnelServer_registerTunnel_Results } // TunnelServer_getServerInfo holds the arguments for a server call to TunnelServer.getServerInfo. type TunnelServer_getServerInfo struct { Ctx context.Context Options capnp.CallOptions Params TunnelServer_getServerInfo_Params Results TunnelServer_getServerInfo_Results } // TunnelServer_unregisterTunnel holds the arguments for a server call to TunnelServer.unregisterTunnel. type TunnelServer_unregisterTunnel struct { Ctx context.Context Options capnp.CallOptions Params TunnelServer_unregisterTunnel_Params Results TunnelServer_unregisterTunnel_Results } type TunnelServer_registerTunnel_Params struct{ capnp.Struct } // TunnelServer_registerTunnel_Params_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Params. const TunnelServer_registerTunnel_Params_TypeID = 0xb70431c0dc014915 func NewTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}) return TunnelServer_registerTunnel_Params{st}, err } func NewRootTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}) return TunnelServer_registerTunnel_Params{st}, err } func ReadRootTunnelServer_registerTunnel_Params(msg *capnp.Message) (TunnelServer_registerTunnel_Params, error) { root, err := msg.RootPtr() return TunnelServer_registerTunnel_Params{root.Struct()}, err } func (s TunnelServer_registerTunnel_Params) String() string { str, _ := text.Marshal(0xb70431c0dc014915, s.Struct) return str } func (s TunnelServer_registerTunnel_Params) OriginCert() ([]byte, error) { p, err := s.Struct.Ptr(0) return []byte(p.Data()), err } func (s TunnelServer_registerTunnel_Params) HasOriginCert() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s TunnelServer_registerTunnel_Params) SetOriginCert(v []byte) error { return s.Struct.SetData(0, v) } func (s TunnelServer_registerTunnel_Params) Hostname() (string, error) { p, err := s.Struct.Ptr(1) return p.Text(), err } func (s TunnelServer_registerTunnel_Params) HasHostname() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s TunnelServer_registerTunnel_Params) HostnameBytes() ([]byte, error) { p, err := s.Struct.Ptr(1) return p.TextBytes(), err } func (s TunnelServer_registerTunnel_Params) SetHostname(v string) error { return s.Struct.SetText(1, v) } func (s TunnelServer_registerTunnel_Params) Options() (RegistrationOptions, error) { p, err := s.Struct.Ptr(2) return RegistrationOptions{Struct: p.Struct()}, err } func (s TunnelServer_registerTunnel_Params) HasOptions() bool { p, err := s.Struct.Ptr(2) return p.IsValid() || err != nil } func (s TunnelServer_registerTunnel_Params) SetOptions(v RegistrationOptions) error { return s.Struct.SetPtr(2, v.Struct.ToPtr()) } // NewOptions sets the options field to a newly // allocated RegistrationOptions struct, preferring placement in s's segment. func (s TunnelServer_registerTunnel_Params) NewOptions() (RegistrationOptions, error) { ss, err := NewRegistrationOptions(s.Struct.Segment()) if err != nil { return RegistrationOptions{}, err } err = s.Struct.SetPtr(2, ss.Struct.ToPtr()) return ss, err } // TunnelServer_registerTunnel_Params_List is a list of TunnelServer_registerTunnel_Params. type TunnelServer_registerTunnel_Params_List struct{ capnp.List } // NewTunnelServer_registerTunnel_Params creates a new list of TunnelServer_registerTunnel_Params. func NewTunnelServer_registerTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Params_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz) return TunnelServer_registerTunnel_Params_List{l}, err } func (s TunnelServer_registerTunnel_Params_List) At(i int) TunnelServer_registerTunnel_Params { return TunnelServer_registerTunnel_Params{s.List.Struct(i)} } func (s TunnelServer_registerTunnel_Params_List) Set(i int, v TunnelServer_registerTunnel_Params) error { return s.List.SetStruct(i, v.Struct) } // TunnelServer_registerTunnel_Params_Promise is a wrapper for a TunnelServer_registerTunnel_Params promised by a client call. type TunnelServer_registerTunnel_Params_Promise struct{ *capnp.Pipeline } func (p TunnelServer_registerTunnel_Params_Promise) Struct() (TunnelServer_registerTunnel_Params, error) { s, err := p.Pipeline.Struct() return TunnelServer_registerTunnel_Params{s}, err } func (p TunnelServer_registerTunnel_Params_Promise) Options() RegistrationOptions_Promise { return RegistrationOptions_Promise{Pipeline: p.Pipeline.GetPipeline(2)} } type TunnelServer_registerTunnel_Results struct{ capnp.Struct } // TunnelServer_registerTunnel_Results_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Results. const TunnelServer_registerTunnel_Results_TypeID = 0xf2c122394f447e8e func NewTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return TunnelServer_registerTunnel_Results{st}, err } func NewRootTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return TunnelServer_registerTunnel_Results{st}, err } func ReadRootTunnelServer_registerTunnel_Results(msg *capnp.Message) (TunnelServer_registerTunnel_Results, error) { root, err := msg.RootPtr() return TunnelServer_registerTunnel_Results{root.Struct()}, err } func (s TunnelServer_registerTunnel_Results) String() string { str, _ := text.Marshal(0xf2c122394f447e8e, s.Struct) return str } func (s TunnelServer_registerTunnel_Results) Result() (TunnelRegistration, error) { p, err := s.Struct.Ptr(0) return TunnelRegistration{Struct: p.Struct()}, err } func (s TunnelServer_registerTunnel_Results) HasResult() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s TunnelServer_registerTunnel_Results) SetResult(v TunnelRegistration) error { return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewResult sets the result field to a newly // allocated TunnelRegistration struct, preferring placement in s's segment. func (s TunnelServer_registerTunnel_Results) NewResult() (TunnelRegistration, error) { ss, err := NewTunnelRegistration(s.Struct.Segment()) if err != nil { return TunnelRegistration{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } // TunnelServer_registerTunnel_Results_List is a list of TunnelServer_registerTunnel_Results. type TunnelServer_registerTunnel_Results_List struct{ capnp.List } // NewTunnelServer_registerTunnel_Results creates a new list of TunnelServer_registerTunnel_Results. func NewTunnelServer_registerTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Results_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) return TunnelServer_registerTunnel_Results_List{l}, err } func (s TunnelServer_registerTunnel_Results_List) At(i int) TunnelServer_registerTunnel_Results { return TunnelServer_registerTunnel_Results{s.List.Struct(i)} } func (s TunnelServer_registerTunnel_Results_List) Set(i int, v TunnelServer_registerTunnel_Results) error { return s.List.SetStruct(i, v.Struct) } // TunnelServer_registerTunnel_Results_Promise is a wrapper for a TunnelServer_registerTunnel_Results promised by a client call. type TunnelServer_registerTunnel_Results_Promise struct{ *capnp.Pipeline } func (p TunnelServer_registerTunnel_Results_Promise) Struct() (TunnelServer_registerTunnel_Results, error) { s, err := p.Pipeline.Struct() return TunnelServer_registerTunnel_Results{s}, err } func (p TunnelServer_registerTunnel_Results_Promise) Result() TunnelRegistration_Promise { return TunnelRegistration_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } type TunnelServer_getServerInfo_Params struct{ capnp.Struct } // TunnelServer_getServerInfo_Params_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Params. const TunnelServer_getServerInfo_Params_TypeID = 0xdc3ed6801961e502 func NewTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}) return TunnelServer_getServerInfo_Params{st}, err } func NewRootTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}) return TunnelServer_getServerInfo_Params{st}, err } func ReadRootTunnelServer_getServerInfo_Params(msg *capnp.Message) (TunnelServer_getServerInfo_Params, error) { root, err := msg.RootPtr() return TunnelServer_getServerInfo_Params{root.Struct()}, err } func (s TunnelServer_getServerInfo_Params) String() string { str, _ := text.Marshal(0xdc3ed6801961e502, s.Struct) return str } // TunnelServer_getServerInfo_Params_List is a list of TunnelServer_getServerInfo_Params. type TunnelServer_getServerInfo_Params_List struct{ capnp.List } // NewTunnelServer_getServerInfo_Params creates a new list of TunnelServer_getServerInfo_Params. func NewTunnelServer_getServerInfo_Params_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Params_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz) return TunnelServer_getServerInfo_Params_List{l}, err } func (s TunnelServer_getServerInfo_Params_List) At(i int) TunnelServer_getServerInfo_Params { return TunnelServer_getServerInfo_Params{s.List.Struct(i)} } func (s TunnelServer_getServerInfo_Params_List) Set(i int, v TunnelServer_getServerInfo_Params) error { return s.List.SetStruct(i, v.Struct) } // TunnelServer_getServerInfo_Params_Promise is a wrapper for a TunnelServer_getServerInfo_Params promised by a client call. type TunnelServer_getServerInfo_Params_Promise struct{ *capnp.Pipeline } func (p TunnelServer_getServerInfo_Params_Promise) Struct() (TunnelServer_getServerInfo_Params, error) { s, err := p.Pipeline.Struct() return TunnelServer_getServerInfo_Params{s}, err } type TunnelServer_getServerInfo_Results struct{ capnp.Struct } // TunnelServer_getServerInfo_Results_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Results. const TunnelServer_getServerInfo_Results_TypeID = 0xe3e37d096a5b564e func NewTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return TunnelServer_getServerInfo_Results{st}, err } func NewRootTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return TunnelServer_getServerInfo_Results{st}, err } func ReadRootTunnelServer_getServerInfo_Results(msg *capnp.Message) (TunnelServer_getServerInfo_Results, error) { root, err := msg.RootPtr() return TunnelServer_getServerInfo_Results{root.Struct()}, err } func (s TunnelServer_getServerInfo_Results) String() string { str, _ := text.Marshal(0xe3e37d096a5b564e, s.Struct) return str } func (s TunnelServer_getServerInfo_Results) Result() (ServerInfo, error) { p, err := s.Struct.Ptr(0) return ServerInfo{Struct: p.Struct()}, err } func (s TunnelServer_getServerInfo_Results) HasResult() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s TunnelServer_getServerInfo_Results) SetResult(v ServerInfo) error { return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewResult sets the result field to a newly // allocated ServerInfo struct, preferring placement in s's segment. func (s TunnelServer_getServerInfo_Results) NewResult() (ServerInfo, error) { ss, err := NewServerInfo(s.Struct.Segment()) if err != nil { return ServerInfo{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } // TunnelServer_getServerInfo_Results_List is a list of TunnelServer_getServerInfo_Results. type TunnelServer_getServerInfo_Results_List struct{ capnp.List } // NewTunnelServer_getServerInfo_Results creates a new list of TunnelServer_getServerInfo_Results. func NewTunnelServer_getServerInfo_Results_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Results_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) return TunnelServer_getServerInfo_Results_List{l}, err } func (s TunnelServer_getServerInfo_Results_List) At(i int) TunnelServer_getServerInfo_Results { return TunnelServer_getServerInfo_Results{s.List.Struct(i)} } func (s TunnelServer_getServerInfo_Results_List) Set(i int, v TunnelServer_getServerInfo_Results) error { return s.List.SetStruct(i, v.Struct) } // TunnelServer_getServerInfo_Results_Promise is a wrapper for a TunnelServer_getServerInfo_Results promised by a client call. type TunnelServer_getServerInfo_Results_Promise struct{ *capnp.Pipeline } func (p TunnelServer_getServerInfo_Results_Promise) Struct() (TunnelServer_getServerInfo_Results, error) { s, err := p.Pipeline.Struct() return TunnelServer_getServerInfo_Results{s}, err } func (p TunnelServer_getServerInfo_Results_Promise) Result() ServerInfo_Promise { return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } type TunnelServer_unregisterTunnel_Params struct{ capnp.Struct } // TunnelServer_unregisterTunnel_Params_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Params. const TunnelServer_unregisterTunnel_Params_TypeID = 0x9b87b390babc2ccf func NewTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}) return TunnelServer_unregisterTunnel_Params{st}, err } func NewRootTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}) return TunnelServer_unregisterTunnel_Params{st}, err } func ReadRootTunnelServer_unregisterTunnel_Params(msg *capnp.Message) (TunnelServer_unregisterTunnel_Params, error) { root, err := msg.RootPtr() return TunnelServer_unregisterTunnel_Params{root.Struct()}, err } func (s TunnelServer_unregisterTunnel_Params) String() string { str, _ := text.Marshal(0x9b87b390babc2ccf, s.Struct) return str } func (s TunnelServer_unregisterTunnel_Params) GracePeriodNanoSec() int64 { return int64(s.Struct.Uint64(0)) } func (s TunnelServer_unregisterTunnel_Params) SetGracePeriodNanoSec(v int64) { s.Struct.SetUint64(0, uint64(v)) } // TunnelServer_unregisterTunnel_Params_List is a list of TunnelServer_unregisterTunnel_Params. type TunnelServer_unregisterTunnel_Params_List struct{ capnp.List } // NewTunnelServer_unregisterTunnel_Params creates a new list of TunnelServer_unregisterTunnel_Params. func NewTunnelServer_unregisterTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Params_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz) return TunnelServer_unregisterTunnel_Params_List{l}, err } func (s TunnelServer_unregisterTunnel_Params_List) At(i int) TunnelServer_unregisterTunnel_Params { return TunnelServer_unregisterTunnel_Params{s.List.Struct(i)} } func (s TunnelServer_unregisterTunnel_Params_List) Set(i int, v TunnelServer_unregisterTunnel_Params) error { return s.List.SetStruct(i, v.Struct) } // TunnelServer_unregisterTunnel_Params_Promise is a wrapper for a TunnelServer_unregisterTunnel_Params promised by a client call. type TunnelServer_unregisterTunnel_Params_Promise struct{ *capnp.Pipeline } func (p TunnelServer_unregisterTunnel_Params_Promise) Struct() (TunnelServer_unregisterTunnel_Params, error) { s, err := p.Pipeline.Struct() return TunnelServer_unregisterTunnel_Params{s}, err } type TunnelServer_unregisterTunnel_Results struct{ capnp.Struct } // TunnelServer_unregisterTunnel_Results_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Results. const TunnelServer_unregisterTunnel_Results_TypeID = 0xa29a916d4ebdd894 func NewTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}) return TunnelServer_unregisterTunnel_Results{st}, err } func NewRootTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}) return TunnelServer_unregisterTunnel_Results{st}, err } func ReadRootTunnelServer_unregisterTunnel_Results(msg *capnp.Message) (TunnelServer_unregisterTunnel_Results, error) { root, err := msg.RootPtr() return TunnelServer_unregisterTunnel_Results{root.Struct()}, err } func (s TunnelServer_unregisterTunnel_Results) String() string { str, _ := text.Marshal(0xa29a916d4ebdd894, s.Struct) return str } // TunnelServer_unregisterTunnel_Results_List is a list of TunnelServer_unregisterTunnel_Results. type TunnelServer_unregisterTunnel_Results_List struct{ capnp.List } // NewTunnelServer_unregisterTunnel_Results creates a new list of TunnelServer_unregisterTunnel_Results. func NewTunnelServer_unregisterTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Results_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz) return TunnelServer_unregisterTunnel_Results_List{l}, err } func (s TunnelServer_unregisterTunnel_Results_List) At(i int) TunnelServer_unregisterTunnel_Results { return TunnelServer_unregisterTunnel_Results{s.List.Struct(i)} } func (s TunnelServer_unregisterTunnel_Results_List) Set(i int, v TunnelServer_unregisterTunnel_Results) error { return s.List.SetStruct(i, v.Struct) } // TunnelServer_unregisterTunnel_Results_Promise is a wrapper for a TunnelServer_unregisterTunnel_Results promised by a client call. type TunnelServer_unregisterTunnel_Results_Promise struct{ *capnp.Pipeline } func (p TunnelServer_unregisterTunnel_Results_Promise) Struct() (TunnelServer_unregisterTunnel_Results, error) { s, err := p.Pipeline.Struct() return TunnelServer_unregisterTunnel_Results{s}, err } const schema_db8274f9144abc7e = "x\xda\x9cV]\x8c\x14\xd5\x12\xae\xef\x9c\x99\xedY\xb2" + "\xcbl\xa7\x87\\\x98\\2\x09Y\xc2OX.\\\xe0" + "f\xd9{\xaf\xfb\xe3\x82\x99uY\xa6\x190\x08\x98\xd0" + "\xcc\x1c\x86^{\xba'\xdd=\x08D~$\x18\x95(" + "Q\x91\x071\x18$1Qc\xfc\x89&\x06\x83\x09\xbe" + "H\x0c1\xbc\xa8\x91Hb\x94\xec\x03DC\xdc\xe8\x83" + "&\xa6\xcd\xe9\xd9\x9ei\x16\x05\xf4\xed\xccw\xeaT}" + "U]\xf5\xd5,\xfb\x07\x1f`\xcb\x93\xdf$\x89\xf4\xe1" + "d[\xf0\xbf\xea\xa53\xff9q\xf1\x08\xa9Y\x16\x1c" + "87\x92\xf9\xc5?\xfc5\x11V|\xc1\xf6A\xbb\xc6" + "\x14\"m\x82\xad'\x04\x97\x96\x9c\xfb\xf0\xd9\xf7\x9ex" + "\x89\xf4\x05\x00QB!Z\xf1\x1b\xfb\x15\x04M\xe5\xfd" + "\x84\xe0\x85\xaf>\x1a\xab>w\xf2\x0c\xa9\x0b\xa2\xfb\xd5" + "\x9c1J\x04\xb3\xf2\xb8r~y\xe2\x83\xc6M\x92\xcb" + "\xab\x1e~]>\x1d\xe4o\x13\x82\xb9?\x0cu\xda7" + "\x0e\x9f'5\x8b\x16\x8b\x86\xe1\xb7|\x04\xda\xcf\xf2\xa8" + "\xfd\x18\x1a\x8fl=\xfe|r\xe2\xf8\x05\xd2\xb3\x88q" + "N\xb6I\xebg\x12.\xb4W\xc2\xe0\xa7\x12\x0e#\x04" + "\xd9w\xfe\xfb\xd6P\xf9\xf2\xc5i\xbe\xc3\xcc\xd6)\x93" + "\xda\x83\x8a:\x89\xa1\x93\x10\xecr<\xdf6\xaa" + "\x82\x88\xd0A\x0c\x1d\x84\x83N\xcd7\x1d\xdbCWk" + "\x1e\x08\xe8\x8a\x95\xe0\x0f>\xf0`\xdd\xdf%l\xdf," + "\x19\xf21Q\xf8m[\x94\xe7\x11\xe9\x03\x1c\xfah\x8c" + "r\xfe\xdf\xb1<\"\xca\xebv\xb4\xf2P\x1e\x16{#" + "V9Q5L+\xfa\x15%3H\xca\xfd-\x9b\xdb" + "\xf1\xdb\x10V\xd5\x0d\xd9\xad\xaf\xe5\xc2\x0c%\xc7%\x11" + "Gm>F\x88\x8a\xdd\xe0(.C\x8b\xa6\xd6\x83!" + "\xa2\xe2B\x89\xafD\x8b\xa9\xb6\x1cY\xa2\xe2\x12\x89\xf7" + "\x82\x01<\x03N\xa4\xad\xc2\x1bD\xc5^\x09\x0fK\xf3" + "\x04\xcf A\xa4\x0d\x86\xee\x07$>*\xf1d\"\x83" + "$\x91\x96\xc7b\xa2\xe2\xb0\xc4\xb7K\xbc\x8de\xd0F" + "\xa4=\x84q\xa2\xe26\x89\xef\x92\xb8\x92\xcc\xc8\x11\xd5" + "\x04\\\xa2bY\xe25\x89\xa7fg\x90\"\xd2\xaa!" + "nI|\x8f\xc4\xdb\xe7d\xd0N\xa4\xd5q\x98\xa8\xe8" + "K\xfc\x90\xc4g \x83\x19D\xda~\x9c$*\x1e\x92" + "\xf8\xd3`\x08J\x96)l?_\x8ew\xc2n\xe1z" + "\xa6cG\xbf\xb9\xe35K-\xa6\x06\x1a\x8d6-8" + "i9\xd1H\xb7d\x9f\x804!\xa89\x8e5vs" + "\x87\xa5}\xa3\xe2a&\xa1\xc0\x81\xae\x96\x8c\x12$\x18" + "\x84\xf3^\xf2MJ;v\xbe\x8c6bhk~\xf2" + "Q\x87r%\xc3\xca\xd7\x9aLLo\xb0\xee;\xf5\x1a" + "\xe5\xca\x86/\xca\x001\x80\x10\xb8u{\xad\xebT7" + "B\xb8U\xd36,j\xde\x94\x9cj\xcd\x15\x9e\x07\xd3" + "\xb1\xf5\xbaa\x99\xdc\xdf\x8bvbh\x8f\xf5\x10\x9b\xde" + "C\xb9Z\xdfF\xa3\"{&\xd5\xec\xebE\x8b\x89\xf4" + "n\x0e}Y\xac\xaf{d_/\xe4\xd0W2\xa4\xe5" + "p5{x\xb7a\xd5\xc5-\xddz'\x15\xab\x08\xbf" + "q\xca\xdb;\x9d\xee\x82\xe1*F\xd5\xfb\x9b\xaf7\x08" + "/-\xc5(\xae\x80}Dz\x8aC\xcf0\xf4\xbb\xa1" + "V\xa1\xab\xb5%\xa6\x8d>\xff\xb3p\xfd\x8d(\x8d\xb9" + "O\x125W3\xa2\x8d\xa4\xea\xfb\x88\xa9y\x05\xadm" + "\x88h\xf9\xa9\xffw\x89\xa9\xab\x14\xb0\xe6\xbf\x01D[" + "_]t\x94\x98:_\x09\"e\xa4\xfeF\xc8\x01\x04" + "Qv\x94\x0b\xf3\x1b@\x10\xc9/\"\x05%\x1a@\x01" + "w_\xee[\xd4;\xe7\xddM\xc5\xa2Uy\xe7z5" + "\xe2\xa4%_Y\xad\x98\xdfq\"\xbd\x83C\x9f\xcd\x10" + "X\xce\x94\x94\xa6\xc7b-t;\x89k\x10\x8e\x84." + "-\x1fK\xff\x99\xa6\xff\xfdR\x85\xf7p\xe8Gb\xdd" + "\xfa\x98\x04\x1f\xe5\xd0\x9f\x8c\xa9\xf0\xe3r\x9b\x1c\xe1\xd0" + "O7\x85M=u\x94H?\xcd\xa1\xbf\xd9R5\xf5" + "ui\xf8\x1a\x87\xfe>\x83\"\\7\xe2\xa9\xd4\xdd\x96" + "X[Ne\xd4\xb4\x85'%`j\xea\xe5\x95\x9c\xf5" + "\x9ap\xab\x86-l\xf8k\x0d\xd3\xaa\xbb\x82Zc\xda" + "\xc8/?\x1cS\x8e\xdf\x03\x00\x00\xff\xff#\xa3\xb8\x8f" func init() { schemas.Register(schema_db8274f9144abc7e, 0x84cb9536a2cf6d3c, 0x9b87b390babc2ccf, 0xa29a916d4ebdd894, 0xb70431c0dc014915, 0xc082ef6e0d42ed1d, 0xc793e50592935b4a, 0xcbd96442ae3bb01a, 0xdc3ed6801961e502, 0xe3e37d096a5b564e, 0xea58385c65416035, 0xf2c122394f447e8e, 0xf2c68e2547ec3866, 0xf41a0f001ad49e46) }