// Code generated by capnpc-go. DO NOT EDIT. package tunnelrpc import ( context "golang.org/x/net/context" strconv "strconv" 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) } func (s Authentication_List) String() string { str, _ := text.MarshalList(0xc082ef6e0d42ed1d, s.List) return str } // 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) } func (s TunnelRegistration_List) String() string { str, _ := text.MarshalList(0xf41a0f001ad49e46, s.List) return str } // 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: 7}) return RegistrationOptions{st}, err } func NewRootRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 7}) 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) } func (s RegistrationOptions) Uuid() (string, error) { p, err := s.Struct.Ptr(6) return p.Text(), err } func (s RegistrationOptions) HasUuid() bool { p, err := s.Struct.Ptr(6) return p.IsValid() || err != nil } func (s RegistrationOptions) UuidBytes() ([]byte, error) { p, err := s.Struct.Ptr(6) return p.TextBytes(), err } func (s RegistrationOptions) SetUuid(v string) error { return s.Struct.SetText(6, 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: 7}, 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) } func (s RegistrationOptions_List) String() string { str, _ := text.MarshalList(0xc793e50592935b4a, s.List) return str } // 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 CapnpConnectParameters struct{ capnp.Struct } // CapnpConnectParameters_TypeID is the unique identifier for the type CapnpConnectParameters. const CapnpConnectParameters_TypeID = 0xa78f37418c1077c8 func NewCapnpConnectParameters(s *capnp.Segment) (CapnpConnectParameters, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5}) return CapnpConnectParameters{st}, err } func NewRootCapnpConnectParameters(s *capnp.Segment) (CapnpConnectParameters, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5}) return CapnpConnectParameters{st}, err } func ReadRootCapnpConnectParameters(msg *capnp.Message) (CapnpConnectParameters, error) { root, err := msg.RootPtr() return CapnpConnectParameters{root.Struct()}, err } func (s CapnpConnectParameters) String() string { str, _ := text.Marshal(0xa78f37418c1077c8, s.Struct) return str } func (s CapnpConnectParameters) OriginCert() ([]byte, error) { p, err := s.Struct.Ptr(0) return []byte(p.Data()), err } func (s CapnpConnectParameters) HasOriginCert() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s CapnpConnectParameters) SetOriginCert(v []byte) error { return s.Struct.SetData(0, v) } func (s CapnpConnectParameters) CloudflaredID() ([]byte, error) { p, err := s.Struct.Ptr(1) return []byte(p.Data()), err } func (s CapnpConnectParameters) HasCloudflaredID() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s CapnpConnectParameters) SetCloudflaredID(v []byte) error { return s.Struct.SetData(1, v) } func (s CapnpConnectParameters) NumPreviousAttempts() uint8 { return s.Struct.Uint8(0) } func (s CapnpConnectParameters) SetNumPreviousAttempts(v uint8) { s.Struct.SetUint8(0, v) } func (s CapnpConnectParameters) Tags() (Tag_List, error) { p, err := s.Struct.Ptr(2) return Tag_List{List: p.List()}, err } func (s CapnpConnectParameters) HasTags() bool { p, err := s.Struct.Ptr(2) return p.IsValid() || err != nil } func (s CapnpConnectParameters) SetTags(v Tag_List) error { return s.Struct.SetPtr(2, v.List.ToPtr()) } // NewTags sets the tags field to a newly // allocated Tag_List, preferring placement in s's segment. func (s CapnpConnectParameters) 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(2, l.List.ToPtr()) return l, err } func (s CapnpConnectParameters) CloudflaredVersion() (string, error) { p, err := s.Struct.Ptr(3) return p.Text(), err } func (s CapnpConnectParameters) HasCloudflaredVersion() bool { p, err := s.Struct.Ptr(3) return p.IsValid() || err != nil } func (s CapnpConnectParameters) CloudflaredVersionBytes() ([]byte, error) { p, err := s.Struct.Ptr(3) return p.TextBytes(), err } func (s CapnpConnectParameters) SetCloudflaredVersion(v string) error { return s.Struct.SetText(3, v) } func (s CapnpConnectParameters) IntentLabel() (string, error) { p, err := s.Struct.Ptr(4) return p.Text(), err } func (s CapnpConnectParameters) HasIntentLabel() bool { p, err := s.Struct.Ptr(4) return p.IsValid() || err != nil } func (s CapnpConnectParameters) IntentLabelBytes() ([]byte, error) { p, err := s.Struct.Ptr(4) return p.TextBytes(), err } func (s CapnpConnectParameters) SetIntentLabel(v string) error { return s.Struct.SetText(4, v) } // CapnpConnectParameters_List is a list of CapnpConnectParameters. type CapnpConnectParameters_List struct{ capnp.List } // NewCapnpConnectParameters creates a new list of CapnpConnectParameters. func NewCapnpConnectParameters_List(s *capnp.Segment, sz int32) (CapnpConnectParameters_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5}, sz) return CapnpConnectParameters_List{l}, err } func (s CapnpConnectParameters_List) At(i int) CapnpConnectParameters { return CapnpConnectParameters{s.List.Struct(i)} } func (s CapnpConnectParameters_List) Set(i int, v CapnpConnectParameters) error { return s.List.SetStruct(i, v.Struct) } func (s CapnpConnectParameters_List) String() string { str, _ := text.MarshalList(0xa78f37418c1077c8, s.List) return str } // CapnpConnectParameters_Promise is a wrapper for a CapnpConnectParameters promised by a client call. type CapnpConnectParameters_Promise struct{ *capnp.Pipeline } func (p CapnpConnectParameters_Promise) Struct() (CapnpConnectParameters, error) { s, err := p.Pipeline.Struct() return CapnpConnectParameters{s}, err } type ConnectResult struct{ capnp.Struct } // ConnectResult_TypeID is the unique identifier for the type ConnectResult. const ConnectResult_TypeID = 0xff8d9848747c956a func NewConnectResult(s *capnp.Segment) (ConnectResult, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}) return ConnectResult{st}, err } func NewRootConnectResult(s *capnp.Segment) (ConnectResult, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}) return ConnectResult{st}, err } func ReadRootConnectResult(msg *capnp.Message) (ConnectResult, error) { root, err := msg.RootPtr() return ConnectResult{root.Struct()}, err } func (s ConnectResult) String() string { str, _ := text.Marshal(0xff8d9848747c956a, s.Struct) return str } func (s ConnectResult) Err() (ConnectError, error) { p, err := s.Struct.Ptr(0) return ConnectError{Struct: p.Struct()}, err } func (s ConnectResult) HasErr() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s ConnectResult) SetErr(v ConnectError) error { return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewErr sets the err field to a newly // allocated ConnectError struct, preferring placement in s's segment. func (s ConnectResult) NewErr() (ConnectError, error) { ss, err := NewConnectError(s.Struct.Segment()) if err != nil { return ConnectError{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } func (s ConnectResult) ServerInfo() (ServerInfo, error) { p, err := s.Struct.Ptr(1) return ServerInfo{Struct: p.Struct()}, err } func (s ConnectResult) HasServerInfo() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s ConnectResult) SetServerInfo(v ServerInfo) error { return s.Struct.SetPtr(1, v.Struct.ToPtr()) } // NewServerInfo sets the serverInfo field to a newly // allocated ServerInfo struct, preferring placement in s's segment. func (s ConnectResult) NewServerInfo() (ServerInfo, error) { ss, err := NewServerInfo(s.Struct.Segment()) if err != nil { return ServerInfo{}, err } err = s.Struct.SetPtr(1, ss.Struct.ToPtr()) return ss, err } func (s ConnectResult) ClientConfig() (ClientConfig, error) { p, err := s.Struct.Ptr(2) return ClientConfig{Struct: p.Struct()}, err } func (s ConnectResult) HasClientConfig() bool { p, err := s.Struct.Ptr(2) return p.IsValid() || err != nil } func (s ConnectResult) SetClientConfig(v ClientConfig) error { return s.Struct.SetPtr(2, v.Struct.ToPtr()) } // NewClientConfig sets the clientConfig field to a newly // allocated ClientConfig struct, preferring placement in s's segment. func (s ConnectResult) NewClientConfig() (ClientConfig, error) { ss, err := NewClientConfig(s.Struct.Segment()) if err != nil { return ClientConfig{}, err } err = s.Struct.SetPtr(2, ss.Struct.ToPtr()) return ss, err } // ConnectResult_List is a list of ConnectResult. type ConnectResult_List struct{ capnp.List } // NewConnectResult creates a new list of ConnectResult. func NewConnectResult_List(s *capnp.Segment, sz int32) (ConnectResult_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz) return ConnectResult_List{l}, err } func (s ConnectResult_List) At(i int) ConnectResult { return ConnectResult{s.List.Struct(i)} } func (s ConnectResult_List) Set(i int, v ConnectResult) error { return s.List.SetStruct(i, v.Struct) } func (s ConnectResult_List) String() string { str, _ := text.MarshalList(0xff8d9848747c956a, s.List) return str } // ConnectResult_Promise is a wrapper for a ConnectResult promised by a client call. type ConnectResult_Promise struct{ *capnp.Pipeline } func (p ConnectResult_Promise) Struct() (ConnectResult, error) { s, err := p.Pipeline.Struct() return ConnectResult{s}, err } func (p ConnectResult_Promise) Err() ConnectError_Promise { return ConnectError_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } func (p ConnectResult_Promise) ServerInfo() ServerInfo_Promise { return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(1)} } func (p ConnectResult_Promise) ClientConfig() ClientConfig_Promise { return ClientConfig_Promise{Pipeline: p.Pipeline.GetPipeline(2)} } type ConnectError struct{ capnp.Struct } // ConnectError_TypeID is the unique identifier for the type ConnectError. const ConnectError_TypeID = 0xb14ce48f4e2abb0d func NewConnectError(s *capnp.Segment) (ConnectError, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}) return ConnectError{st}, err } func NewRootConnectError(s *capnp.Segment) (ConnectError, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}) return ConnectError{st}, err } func ReadRootConnectError(msg *capnp.Message) (ConnectError, error) { root, err := msg.RootPtr() return ConnectError{root.Struct()}, err } func (s ConnectError) String() string { str, _ := text.Marshal(0xb14ce48f4e2abb0d, s.Struct) return str } func (s ConnectError) Cause() (string, error) { p, err := s.Struct.Ptr(0) return p.Text(), err } func (s ConnectError) HasCause() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s ConnectError) CauseBytes() ([]byte, error) { p, err := s.Struct.Ptr(0) return p.TextBytes(), err } func (s ConnectError) SetCause(v string) error { return s.Struct.SetText(0, v) } func (s ConnectError) RetryAfter() int64 { return int64(s.Struct.Uint64(0)) } func (s ConnectError) SetRetryAfter(v int64) { s.Struct.SetUint64(0, uint64(v)) } func (s ConnectError) ShouldRetry() bool { return s.Struct.Bit(64) } func (s ConnectError) SetShouldRetry(v bool) { s.Struct.SetBit(64, v) } // ConnectError_List is a list of ConnectError. type ConnectError_List struct{ capnp.List } // NewConnectError creates a new list of ConnectError. func NewConnectError_List(s *capnp.Segment, sz int32) (ConnectError_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}, sz) return ConnectError_List{l}, err } func (s ConnectError_List) At(i int) ConnectError { return ConnectError{s.List.Struct(i)} } func (s ConnectError_List) Set(i int, v ConnectError) error { return s.List.SetStruct(i, v.Struct) } func (s ConnectError_List) String() string { str, _ := text.MarshalList(0xb14ce48f4e2abb0d, s.List) return str } // ConnectError_Promise is a wrapper for a ConnectError promised by a client call. type ConnectError_Promise struct{ *capnp.Pipeline } func (p ConnectError_Promise) Struct() (ConnectError, error) { s, err := p.Pipeline.Struct() return ConnectError{s}, err } type ClientConfig struct{ capnp.Struct } // ClientConfig_TypeID is the unique identifier for the type ClientConfig. const ClientConfig_TypeID = 0xf0a143f1c95a678e func NewClientConfig(s *capnp.Segment) (ClientConfig, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}) return ClientConfig{st}, err } func NewRootClientConfig(s *capnp.Segment) (ClientConfig, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}) return ClientConfig{st}, err } func ReadRootClientConfig(msg *capnp.Message) (ClientConfig, error) { root, err := msg.RootPtr() return ClientConfig{root.Struct()}, err } func (s ClientConfig) String() string { str, _ := text.Marshal(0xf0a143f1c95a678e, s.Struct) return str } func (s ClientConfig) Version() uint64 { return s.Struct.Uint64(0) } func (s ClientConfig) SetVersion(v uint64) { s.Struct.SetUint64(0, v) } func (s ClientConfig) SupervisorConfig() (SupervisorConfig, error) { p, err := s.Struct.Ptr(0) return SupervisorConfig{Struct: p.Struct()}, err } func (s ClientConfig) HasSupervisorConfig() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s ClientConfig) SetSupervisorConfig(v SupervisorConfig) error { return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewSupervisorConfig sets the supervisorConfig field to a newly // allocated SupervisorConfig struct, preferring placement in s's segment. func (s ClientConfig) NewSupervisorConfig() (SupervisorConfig, error) { ss, err := NewSupervisorConfig(s.Struct.Segment()) if err != nil { return SupervisorConfig{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } func (s ClientConfig) EdgeConnectionConfig() (EdgeConnectionConfig, error) { p, err := s.Struct.Ptr(1) return EdgeConnectionConfig{Struct: p.Struct()}, err } func (s ClientConfig) HasEdgeConnectionConfig() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s ClientConfig) SetEdgeConnectionConfig(v EdgeConnectionConfig) error { return s.Struct.SetPtr(1, v.Struct.ToPtr()) } // NewEdgeConnectionConfig sets the edgeConnectionConfig field to a newly // allocated EdgeConnectionConfig struct, preferring placement in s's segment. func (s ClientConfig) NewEdgeConnectionConfig() (EdgeConnectionConfig, error) { ss, err := NewEdgeConnectionConfig(s.Struct.Segment()) if err != nil { return EdgeConnectionConfig{}, err } err = s.Struct.SetPtr(1, ss.Struct.ToPtr()) return ss, err } func (s ClientConfig) DohProxyConfigs() (DoHProxyConfig_List, error) { p, err := s.Struct.Ptr(2) return DoHProxyConfig_List{List: p.List()}, err } func (s ClientConfig) HasDohProxyConfigs() bool { p, err := s.Struct.Ptr(2) return p.IsValid() || err != nil } func (s ClientConfig) SetDohProxyConfigs(v DoHProxyConfig_List) error { return s.Struct.SetPtr(2, v.List.ToPtr()) } // NewDohProxyConfigs sets the dohProxyConfigs field to a newly // allocated DoHProxyConfig_List, preferring placement in s's segment. func (s ClientConfig) NewDohProxyConfigs(n int32) (DoHProxyConfig_List, error) { l, err := NewDoHProxyConfig_List(s.Struct.Segment(), n) if err != nil { return DoHProxyConfig_List{}, err } err = s.Struct.SetPtr(2, l.List.ToPtr()) return l, err } func (s ClientConfig) ReverseProxyConfigs() (ReverseProxyConfig_List, error) { p, err := s.Struct.Ptr(3) return ReverseProxyConfig_List{List: p.List()}, err } func (s ClientConfig) HasReverseProxyConfigs() bool { p, err := s.Struct.Ptr(3) return p.IsValid() || err != nil } func (s ClientConfig) SetReverseProxyConfigs(v ReverseProxyConfig_List) error { return s.Struct.SetPtr(3, v.List.ToPtr()) } // NewReverseProxyConfigs sets the reverseProxyConfigs field to a newly // allocated ReverseProxyConfig_List, preferring placement in s's segment. func (s ClientConfig) NewReverseProxyConfigs(n int32) (ReverseProxyConfig_List, error) { l, err := NewReverseProxyConfig_List(s.Struct.Segment(), n) if err != nil { return ReverseProxyConfig_List{}, err } err = s.Struct.SetPtr(3, l.List.ToPtr()) return l, err } // ClientConfig_List is a list of ClientConfig. type ClientConfig_List struct{ capnp.List } // NewClientConfig creates a new list of ClientConfig. func NewClientConfig_List(s *capnp.Segment, sz int32) (ClientConfig_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}, sz) return ClientConfig_List{l}, err } func (s ClientConfig_List) At(i int) ClientConfig { return ClientConfig{s.List.Struct(i)} } func (s ClientConfig_List) Set(i int, v ClientConfig) error { return s.List.SetStruct(i, v.Struct) } func (s ClientConfig_List) String() string { str, _ := text.MarshalList(0xf0a143f1c95a678e, s.List) return str } // ClientConfig_Promise is a wrapper for a ClientConfig promised by a client call. type ClientConfig_Promise struct{ *capnp.Pipeline } func (p ClientConfig_Promise) Struct() (ClientConfig, error) { s, err := p.Pipeline.Struct() return ClientConfig{s}, err } func (p ClientConfig_Promise) SupervisorConfig() SupervisorConfig_Promise { return SupervisorConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } func (p ClientConfig_Promise) EdgeConnectionConfig() EdgeConnectionConfig_Promise { return EdgeConnectionConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)} } type SupervisorConfig struct{ capnp.Struct } // SupervisorConfig_TypeID is the unique identifier for the type SupervisorConfig. const SupervisorConfig_TypeID = 0xf7f49b3f779ae258 func NewSupervisorConfig(s *capnp.Segment) (SupervisorConfig, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0}) return SupervisorConfig{st}, err } func NewRootSupervisorConfig(s *capnp.Segment) (SupervisorConfig, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0}) return SupervisorConfig{st}, err } func ReadRootSupervisorConfig(msg *capnp.Message) (SupervisorConfig, error) { root, err := msg.RootPtr() return SupervisorConfig{root.Struct()}, err } func (s SupervisorConfig) String() string { str, _ := text.Marshal(0xf7f49b3f779ae258, s.Struct) return str } func (s SupervisorConfig) AutoUpdateFrequency() int64 { return int64(s.Struct.Uint64(0)) } func (s SupervisorConfig) SetAutoUpdateFrequency(v int64) { s.Struct.SetUint64(0, uint64(v)) } func (s SupervisorConfig) MetricsUpdateFrequency() int64 { return int64(s.Struct.Uint64(8)) } func (s SupervisorConfig) SetMetricsUpdateFrequency(v int64) { s.Struct.SetUint64(8, uint64(v)) } func (s SupervisorConfig) GracePeriod() int64 { return int64(s.Struct.Uint64(16)) } func (s SupervisorConfig) SetGracePeriod(v int64) { s.Struct.SetUint64(16, uint64(v)) } // SupervisorConfig_List is a list of SupervisorConfig. type SupervisorConfig_List struct{ capnp.List } // NewSupervisorConfig creates a new list of SupervisorConfig. func NewSupervisorConfig_List(s *capnp.Segment, sz int32) (SupervisorConfig_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0}, sz) return SupervisorConfig_List{l}, err } func (s SupervisorConfig_List) At(i int) SupervisorConfig { return SupervisorConfig{s.List.Struct(i)} } func (s SupervisorConfig_List) Set(i int, v SupervisorConfig) error { return s.List.SetStruct(i, v.Struct) } func (s SupervisorConfig_List) String() string { str, _ := text.MarshalList(0xf7f49b3f779ae258, s.List) return str } // SupervisorConfig_Promise is a wrapper for a SupervisorConfig promised by a client call. type SupervisorConfig_Promise struct{ *capnp.Pipeline } func (p SupervisorConfig_Promise) Struct() (SupervisorConfig, error) { s, err := p.Pipeline.Struct() return SupervisorConfig{s}, err } type EdgeConnectionConfig struct{ capnp.Struct } // EdgeConnectionConfig_TypeID is the unique identifier for the type EdgeConnectionConfig. const EdgeConnectionConfig_TypeID = 0xc744e349009087aa func NewEdgeConnectionConfig(s *capnp.Segment) (EdgeConnectionConfig, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1}) return EdgeConnectionConfig{st}, err } func NewRootEdgeConnectionConfig(s *capnp.Segment) (EdgeConnectionConfig, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1}) return EdgeConnectionConfig{st}, err } func ReadRootEdgeConnectionConfig(msg *capnp.Message) (EdgeConnectionConfig, error) { root, err := msg.RootPtr() return EdgeConnectionConfig{root.Struct()}, err } func (s EdgeConnectionConfig) String() string { str, _ := text.Marshal(0xc744e349009087aa, s.Struct) return str } func (s EdgeConnectionConfig) NumHAConnections() uint8 { return s.Struct.Uint8(0) } func (s EdgeConnectionConfig) SetNumHAConnections(v uint8) { s.Struct.SetUint8(0, v) } func (s EdgeConnectionConfig) HeartbeatInterval() int64 { return int64(s.Struct.Uint64(8)) } func (s EdgeConnectionConfig) SetHeartbeatInterval(v int64) { s.Struct.SetUint64(8, uint64(v)) } func (s EdgeConnectionConfig) Timeout() int64 { return int64(s.Struct.Uint64(16)) } func (s EdgeConnectionConfig) SetTimeout(v int64) { s.Struct.SetUint64(16, uint64(v)) } func (s EdgeConnectionConfig) MaxFailedHeartbeats() uint64 { return s.Struct.Uint64(24) } func (s EdgeConnectionConfig) SetMaxFailedHeartbeats(v uint64) { s.Struct.SetUint64(24, v) } func (s EdgeConnectionConfig) UserCredentialPath() (string, error) { p, err := s.Struct.Ptr(0) return p.Text(), err } func (s EdgeConnectionConfig) HasUserCredentialPath() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s EdgeConnectionConfig) UserCredentialPathBytes() ([]byte, error) { p, err := s.Struct.Ptr(0) return p.TextBytes(), err } func (s EdgeConnectionConfig) SetUserCredentialPath(v string) error { return s.Struct.SetText(0, v) } // EdgeConnectionConfig_List is a list of EdgeConnectionConfig. type EdgeConnectionConfig_List struct{ capnp.List } // NewEdgeConnectionConfig creates a new list of EdgeConnectionConfig. func NewEdgeConnectionConfig_List(s *capnp.Segment, sz int32) (EdgeConnectionConfig_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1}, sz) return EdgeConnectionConfig_List{l}, err } func (s EdgeConnectionConfig_List) At(i int) EdgeConnectionConfig { return EdgeConnectionConfig{s.List.Struct(i)} } func (s EdgeConnectionConfig_List) Set(i int, v EdgeConnectionConfig) error { return s.List.SetStruct(i, v.Struct) } func (s EdgeConnectionConfig_List) String() string { str, _ := text.MarshalList(0xc744e349009087aa, s.List) return str } // EdgeConnectionConfig_Promise is a wrapper for a EdgeConnectionConfig promised by a client call. type EdgeConnectionConfig_Promise struct{ *capnp.Pipeline } func (p EdgeConnectionConfig_Promise) Struct() (EdgeConnectionConfig, error) { s, err := p.Pipeline.Struct() return EdgeConnectionConfig{s}, err } type ReverseProxyConfig struct{ capnp.Struct } type ReverseProxyConfig_originConfig ReverseProxyConfig type ReverseProxyConfig_originConfig_Which uint16 const ( ReverseProxyConfig_originConfig_Which_http ReverseProxyConfig_originConfig_Which = 0 ReverseProxyConfig_originConfig_Which_websocket ReverseProxyConfig_originConfig_Which = 1 ReverseProxyConfig_originConfig_Which_helloWorld ReverseProxyConfig_originConfig_Which = 2 ) func (w ReverseProxyConfig_originConfig_Which) String() string { const s = "httpwebsockethelloWorld" switch w { case ReverseProxyConfig_originConfig_Which_http: return s[0:4] case ReverseProxyConfig_originConfig_Which_websocket: return s[4:13] case ReverseProxyConfig_originConfig_Which_helloWorld: return s[13:23] } return "ReverseProxyConfig_originConfig_Which(" + strconv.FormatUint(uint64(w), 10) + ")" } // ReverseProxyConfig_TypeID is the unique identifier for the type ReverseProxyConfig. const ReverseProxyConfig_TypeID = 0xc766a92976e389c4 func NewReverseProxyConfig(s *capnp.Segment) (ReverseProxyConfig, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 2}) return ReverseProxyConfig{st}, err } func NewRootReverseProxyConfig(s *capnp.Segment) (ReverseProxyConfig, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 2}) return ReverseProxyConfig{st}, err } func ReadRootReverseProxyConfig(msg *capnp.Message) (ReverseProxyConfig, error) { root, err := msg.RootPtr() return ReverseProxyConfig{root.Struct()}, err } func (s ReverseProxyConfig) String() string { str, _ := text.Marshal(0xc766a92976e389c4, s.Struct) return str } func (s ReverseProxyConfig) TunnelHostname() (string, error) { p, err := s.Struct.Ptr(0) return p.Text(), err } func (s ReverseProxyConfig) HasTunnelHostname() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s ReverseProxyConfig) TunnelHostnameBytes() ([]byte, error) { p, err := s.Struct.Ptr(0) return p.TextBytes(), err } func (s ReverseProxyConfig) SetTunnelHostname(v string) error { return s.Struct.SetText(0, v) } func (s ReverseProxyConfig) OriginConfig() ReverseProxyConfig_originConfig { return ReverseProxyConfig_originConfig(s) } func (s ReverseProxyConfig_originConfig) Which() ReverseProxyConfig_originConfig_Which { return ReverseProxyConfig_originConfig_Which(s.Struct.Uint16(0)) } func (s ReverseProxyConfig_originConfig) Http() (HTTPOriginConfig, error) { if s.Struct.Uint16(0) != 0 { panic("Which() != http") } p, err := s.Struct.Ptr(1) return HTTPOriginConfig{Struct: p.Struct()}, err } func (s ReverseProxyConfig_originConfig) HasHttp() bool { if s.Struct.Uint16(0) != 0 { return false } p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s ReverseProxyConfig_originConfig) SetHttp(v HTTPOriginConfig) error { s.Struct.SetUint16(0, 0) return s.Struct.SetPtr(1, v.Struct.ToPtr()) } // NewHttp sets the http field to a newly // allocated HTTPOriginConfig struct, preferring placement in s's segment. func (s ReverseProxyConfig_originConfig) NewHttp() (HTTPOriginConfig, error) { s.Struct.SetUint16(0, 0) ss, err := NewHTTPOriginConfig(s.Struct.Segment()) if err != nil { return HTTPOriginConfig{}, err } err = s.Struct.SetPtr(1, ss.Struct.ToPtr()) return ss, err } func (s ReverseProxyConfig_originConfig) Websocket() (WebSocketOriginConfig, error) { if s.Struct.Uint16(0) != 1 { panic("Which() != websocket") } p, err := s.Struct.Ptr(1) return WebSocketOriginConfig{Struct: p.Struct()}, err } func (s ReverseProxyConfig_originConfig) HasWebsocket() bool { if s.Struct.Uint16(0) != 1 { return false } p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s ReverseProxyConfig_originConfig) SetWebsocket(v WebSocketOriginConfig) error { s.Struct.SetUint16(0, 1) return s.Struct.SetPtr(1, v.Struct.ToPtr()) } // NewWebsocket sets the websocket field to a newly // allocated WebSocketOriginConfig struct, preferring placement in s's segment. func (s ReverseProxyConfig_originConfig) NewWebsocket() (WebSocketOriginConfig, error) { s.Struct.SetUint16(0, 1) ss, err := NewWebSocketOriginConfig(s.Struct.Segment()) if err != nil { return WebSocketOriginConfig{}, err } err = s.Struct.SetPtr(1, ss.Struct.ToPtr()) return ss, err } func (s ReverseProxyConfig_originConfig) HelloWorld() (HelloWorldOriginConfig, error) { if s.Struct.Uint16(0) != 2 { panic("Which() != helloWorld") } p, err := s.Struct.Ptr(1) return HelloWorldOriginConfig{Struct: p.Struct()}, err } func (s ReverseProxyConfig_originConfig) HasHelloWorld() bool { if s.Struct.Uint16(0) != 2 { return false } p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s ReverseProxyConfig_originConfig) SetHelloWorld(v HelloWorldOriginConfig) error { s.Struct.SetUint16(0, 2) return s.Struct.SetPtr(1, v.Struct.ToPtr()) } // NewHelloWorld sets the helloWorld field to a newly // allocated HelloWorldOriginConfig struct, preferring placement in s's segment. func (s ReverseProxyConfig_originConfig) NewHelloWorld() (HelloWorldOriginConfig, error) { s.Struct.SetUint16(0, 2) ss, err := NewHelloWorldOriginConfig(s.Struct.Segment()) if err != nil { return HelloWorldOriginConfig{}, err } err = s.Struct.SetPtr(1, ss.Struct.ToPtr()) return ss, err } func (s ReverseProxyConfig) Retries() uint64 { return s.Struct.Uint64(8) } func (s ReverseProxyConfig) SetRetries(v uint64) { s.Struct.SetUint64(8, v) } func (s ReverseProxyConfig) ConnectionTimeout() int64 { return int64(s.Struct.Uint64(16)) } func (s ReverseProxyConfig) SetConnectionTimeout(v int64) { s.Struct.SetUint64(16, uint64(v)) } func (s ReverseProxyConfig) CompressionQuality() uint64 { return s.Struct.Uint64(24) } func (s ReverseProxyConfig) SetCompressionQuality(v uint64) { s.Struct.SetUint64(24, v) } // ReverseProxyConfig_List is a list of ReverseProxyConfig. type ReverseProxyConfig_List struct{ capnp.List } // NewReverseProxyConfig creates a new list of ReverseProxyConfig. func NewReverseProxyConfig_List(s *capnp.Segment, sz int32) (ReverseProxyConfig_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 32, PointerCount: 2}, sz) return ReverseProxyConfig_List{l}, err } func (s ReverseProxyConfig_List) At(i int) ReverseProxyConfig { return ReverseProxyConfig{s.List.Struct(i)} } func (s ReverseProxyConfig_List) Set(i int, v ReverseProxyConfig) error { return s.List.SetStruct(i, v.Struct) } func (s ReverseProxyConfig_List) String() string { str, _ := text.MarshalList(0xc766a92976e389c4, s.List) return str } // ReverseProxyConfig_Promise is a wrapper for a ReverseProxyConfig promised by a client call. type ReverseProxyConfig_Promise struct{ *capnp.Pipeline } func (p ReverseProxyConfig_Promise) Struct() (ReverseProxyConfig, error) { s, err := p.Pipeline.Struct() return ReverseProxyConfig{s}, err } func (p ReverseProxyConfig_Promise) OriginConfig() ReverseProxyConfig_originConfig_Promise { return ReverseProxyConfig_originConfig_Promise{p.Pipeline} } // ReverseProxyConfig_originConfig_Promise is a wrapper for a ReverseProxyConfig_originConfig promised by a client call. type ReverseProxyConfig_originConfig_Promise struct{ *capnp.Pipeline } func (p ReverseProxyConfig_originConfig_Promise) Struct() (ReverseProxyConfig_originConfig, error) { s, err := p.Pipeline.Struct() return ReverseProxyConfig_originConfig{s}, err } func (p ReverseProxyConfig_originConfig_Promise) Http() HTTPOriginConfig_Promise { return HTTPOriginConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)} } func (p ReverseProxyConfig_originConfig_Promise) Websocket() WebSocketOriginConfig_Promise { return WebSocketOriginConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)} } func (p ReverseProxyConfig_originConfig_Promise) HelloWorld() HelloWorldOriginConfig_Promise { return HelloWorldOriginConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)} } type WebSocketOriginConfig struct{ capnp.Struct } // WebSocketOriginConfig_TypeID is the unique identifier for the type WebSocketOriginConfig. const WebSocketOriginConfig_TypeID = 0xf9c895683ed9ac4c func NewWebSocketOriginConfig(s *capnp.Segment) (WebSocketOriginConfig, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}) return WebSocketOriginConfig{st}, err } func NewRootWebSocketOriginConfig(s *capnp.Segment) (WebSocketOriginConfig, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}) return WebSocketOriginConfig{st}, err } func ReadRootWebSocketOriginConfig(msg *capnp.Message) (WebSocketOriginConfig, error) { root, err := msg.RootPtr() return WebSocketOriginConfig{root.Struct()}, err } func (s WebSocketOriginConfig) String() string { str, _ := text.Marshal(0xf9c895683ed9ac4c, s.Struct) return str } func (s WebSocketOriginConfig) UrlString() (string, error) { p, err := s.Struct.Ptr(0) return p.Text(), err } func (s WebSocketOriginConfig) HasUrlString() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s WebSocketOriginConfig) UrlStringBytes() ([]byte, error) { p, err := s.Struct.Ptr(0) return p.TextBytes(), err } func (s WebSocketOriginConfig) SetUrlString(v string) error { return s.Struct.SetText(0, v) } func (s WebSocketOriginConfig) TlsVerify() bool { return s.Struct.Bit(0) } func (s WebSocketOriginConfig) SetTlsVerify(v bool) { s.Struct.SetBit(0, v) } func (s WebSocketOriginConfig) OriginCAPool() (string, error) { p, err := s.Struct.Ptr(1) return p.Text(), err } func (s WebSocketOriginConfig) HasOriginCAPool() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s WebSocketOriginConfig) OriginCAPoolBytes() ([]byte, error) { p, err := s.Struct.Ptr(1) return p.TextBytes(), err } func (s WebSocketOriginConfig) SetOriginCAPool(v string) error { return s.Struct.SetText(1, v) } func (s WebSocketOriginConfig) OriginServerName() (string, error) { p, err := s.Struct.Ptr(2) return p.Text(), err } func (s WebSocketOriginConfig) HasOriginServerName() bool { p, err := s.Struct.Ptr(2) return p.IsValid() || err != nil } func (s WebSocketOriginConfig) OriginServerNameBytes() ([]byte, error) { p, err := s.Struct.Ptr(2) return p.TextBytes(), err } func (s WebSocketOriginConfig) SetOriginServerName(v string) error { return s.Struct.SetText(2, v) } // WebSocketOriginConfig_List is a list of WebSocketOriginConfig. type WebSocketOriginConfig_List struct{ capnp.List } // NewWebSocketOriginConfig creates a new list of WebSocketOriginConfig. func NewWebSocketOriginConfig_List(s *capnp.Segment, sz int32) (WebSocketOriginConfig_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}, sz) return WebSocketOriginConfig_List{l}, err } func (s WebSocketOriginConfig_List) At(i int) WebSocketOriginConfig { return WebSocketOriginConfig{s.List.Struct(i)} } func (s WebSocketOriginConfig_List) Set(i int, v WebSocketOriginConfig) error { return s.List.SetStruct(i, v.Struct) } func (s WebSocketOriginConfig_List) String() string { str, _ := text.MarshalList(0xf9c895683ed9ac4c, s.List) return str } // WebSocketOriginConfig_Promise is a wrapper for a WebSocketOriginConfig promised by a client call. type WebSocketOriginConfig_Promise struct{ *capnp.Pipeline } func (p WebSocketOriginConfig_Promise) Struct() (WebSocketOriginConfig, error) { s, err := p.Pipeline.Struct() return WebSocketOriginConfig{s}, err } type HTTPOriginConfig struct{ capnp.Struct } // HTTPOriginConfig_TypeID is the unique identifier for the type HTTPOriginConfig. const HTTPOriginConfig_TypeID = 0xe4a6a1bc139211b4 func NewHTTPOriginConfig(s *capnp.Segment) (HTTPOriginConfig, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 56, PointerCount: 3}) return HTTPOriginConfig{st}, err } func NewRootHTTPOriginConfig(s *capnp.Segment) (HTTPOriginConfig, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 56, PointerCount: 3}) return HTTPOriginConfig{st}, err } func ReadRootHTTPOriginConfig(msg *capnp.Message) (HTTPOriginConfig, error) { root, err := msg.RootPtr() return HTTPOriginConfig{root.Struct()}, err } func (s HTTPOriginConfig) String() string { str, _ := text.Marshal(0xe4a6a1bc139211b4, s.Struct) return str } func (s HTTPOriginConfig) UrlString() (string, error) { p, err := s.Struct.Ptr(0) return p.Text(), err } func (s HTTPOriginConfig) HasUrlString() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s HTTPOriginConfig) UrlStringBytes() ([]byte, error) { p, err := s.Struct.Ptr(0) return p.TextBytes(), err } func (s HTTPOriginConfig) SetUrlString(v string) error { return s.Struct.SetText(0, v) } func (s HTTPOriginConfig) TcpKeepAlive() int64 { return int64(s.Struct.Uint64(0)) } func (s HTTPOriginConfig) SetTcpKeepAlive(v int64) { s.Struct.SetUint64(0, uint64(v)) } func (s HTTPOriginConfig) DialDualStack() bool { return s.Struct.Bit(64) } func (s HTTPOriginConfig) SetDialDualStack(v bool) { s.Struct.SetBit(64, v) } func (s HTTPOriginConfig) TlsHandshakeTimeout() int64 { return int64(s.Struct.Uint64(16)) } func (s HTTPOriginConfig) SetTlsHandshakeTimeout(v int64) { s.Struct.SetUint64(16, uint64(v)) } func (s HTTPOriginConfig) TlsVerify() bool { return s.Struct.Bit(65) } func (s HTTPOriginConfig) SetTlsVerify(v bool) { s.Struct.SetBit(65, v) } func (s HTTPOriginConfig) OriginCAPool() (string, error) { p, err := s.Struct.Ptr(1) return p.Text(), err } func (s HTTPOriginConfig) HasOriginCAPool() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s HTTPOriginConfig) OriginCAPoolBytes() ([]byte, error) { p, err := s.Struct.Ptr(1) return p.TextBytes(), err } func (s HTTPOriginConfig) SetOriginCAPool(v string) error { return s.Struct.SetText(1, v) } func (s HTTPOriginConfig) OriginServerName() (string, error) { p, err := s.Struct.Ptr(2) return p.Text(), err } func (s HTTPOriginConfig) HasOriginServerName() bool { p, err := s.Struct.Ptr(2) return p.IsValid() || err != nil } func (s HTTPOriginConfig) OriginServerNameBytes() ([]byte, error) { p, err := s.Struct.Ptr(2) return p.TextBytes(), err } func (s HTTPOriginConfig) SetOriginServerName(v string) error { return s.Struct.SetText(2, v) } func (s HTTPOriginConfig) MaxIdleConnections() uint64 { return s.Struct.Uint64(24) } func (s HTTPOriginConfig) SetMaxIdleConnections(v uint64) { s.Struct.SetUint64(24, v) } func (s HTTPOriginConfig) IdleConnectionTimeout() int64 { return int64(s.Struct.Uint64(32)) } func (s HTTPOriginConfig) SetIdleConnectionTimeout(v int64) { s.Struct.SetUint64(32, uint64(v)) } func (s HTTPOriginConfig) ProxyConnectionTimeout() int64 { return int64(s.Struct.Uint64(40)) } func (s HTTPOriginConfig) SetProxyConnectionTimeout(v int64) { s.Struct.SetUint64(40, uint64(v)) } func (s HTTPOriginConfig) ExpectContinueTimeout() int64 { return int64(s.Struct.Uint64(48)) } func (s HTTPOriginConfig) SetExpectContinueTimeout(v int64) { s.Struct.SetUint64(48, uint64(v)) } func (s HTTPOriginConfig) ChunkedEncoding() bool { return s.Struct.Bit(66) } func (s HTTPOriginConfig) SetChunkedEncoding(v bool) { s.Struct.SetBit(66, v) } // HTTPOriginConfig_List is a list of HTTPOriginConfig. type HTTPOriginConfig_List struct{ capnp.List } // NewHTTPOriginConfig creates a new list of HTTPOriginConfig. func NewHTTPOriginConfig_List(s *capnp.Segment, sz int32) (HTTPOriginConfig_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 56, PointerCount: 3}, sz) return HTTPOriginConfig_List{l}, err } func (s HTTPOriginConfig_List) At(i int) HTTPOriginConfig { return HTTPOriginConfig{s.List.Struct(i)} } func (s HTTPOriginConfig_List) Set(i int, v HTTPOriginConfig) error { return s.List.SetStruct(i, v.Struct) } func (s HTTPOriginConfig_List) String() string { str, _ := text.MarshalList(0xe4a6a1bc139211b4, s.List) return str } // HTTPOriginConfig_Promise is a wrapper for a HTTPOriginConfig promised by a client call. type HTTPOriginConfig_Promise struct{ *capnp.Pipeline } func (p HTTPOriginConfig_Promise) Struct() (HTTPOriginConfig, error) { s, err := p.Pipeline.Struct() return HTTPOriginConfig{s}, err } type DoHProxyConfig struct{ capnp.Struct } // DoHProxyConfig_TypeID is the unique identifier for the type DoHProxyConfig. const DoHProxyConfig_TypeID = 0xb167b0bebe562cd0 func NewDoHProxyConfig(s *capnp.Segment) (DoHProxyConfig, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}) return DoHProxyConfig{st}, err } func NewRootDoHProxyConfig(s *capnp.Segment) (DoHProxyConfig, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}) return DoHProxyConfig{st}, err } func ReadRootDoHProxyConfig(msg *capnp.Message) (DoHProxyConfig, error) { root, err := msg.RootPtr() return DoHProxyConfig{root.Struct()}, err } func (s DoHProxyConfig) String() string { str, _ := text.Marshal(0xb167b0bebe562cd0, s.Struct) return str } func (s DoHProxyConfig) ListenHost() (string, error) { p, err := s.Struct.Ptr(0) return p.Text(), err } func (s DoHProxyConfig) HasListenHost() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s DoHProxyConfig) ListenHostBytes() ([]byte, error) { p, err := s.Struct.Ptr(0) return p.TextBytes(), err } func (s DoHProxyConfig) SetListenHost(v string) error { return s.Struct.SetText(0, v) } func (s DoHProxyConfig) ListenPort() uint16 { return s.Struct.Uint16(0) } func (s DoHProxyConfig) SetListenPort(v uint16) { s.Struct.SetUint16(0, v) } func (s DoHProxyConfig) Upstreams() (capnp.TextList, error) { p, err := s.Struct.Ptr(1) return capnp.TextList{List: p.List()}, err } func (s DoHProxyConfig) HasUpstreams() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s DoHProxyConfig) SetUpstreams(v capnp.TextList) error { return s.Struct.SetPtr(1, v.List.ToPtr()) } // NewUpstreams sets the upstreams field to a newly // allocated capnp.TextList, preferring placement in s's segment. func (s DoHProxyConfig) NewUpstreams(n int32) (capnp.TextList, error) { l, err := capnp.NewTextList(s.Struct.Segment(), n) if err != nil { return capnp.TextList{}, err } err = s.Struct.SetPtr(1, l.List.ToPtr()) return l, err } // DoHProxyConfig_List is a list of DoHProxyConfig. type DoHProxyConfig_List struct{ capnp.List } // NewDoHProxyConfig creates a new list of DoHProxyConfig. func NewDoHProxyConfig_List(s *capnp.Segment, sz int32) (DoHProxyConfig_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz) return DoHProxyConfig_List{l}, err } func (s DoHProxyConfig_List) At(i int) DoHProxyConfig { return DoHProxyConfig{s.List.Struct(i)} } func (s DoHProxyConfig_List) Set(i int, v DoHProxyConfig) error { return s.List.SetStruct(i, v.Struct) } func (s DoHProxyConfig_List) String() string { str, _ := text.MarshalList(0xb167b0bebe562cd0, s.List) return str } // DoHProxyConfig_Promise is a wrapper for a DoHProxyConfig promised by a client call. type DoHProxyConfig_Promise struct{ *capnp.Pipeline } func (p DoHProxyConfig_Promise) Struct() (DoHProxyConfig, error) { s, err := p.Pipeline.Struct() return DoHProxyConfig{s}, err } type HelloWorldOriginConfig struct{ capnp.Struct } // HelloWorldOriginConfig_TypeID is the unique identifier for the type HelloWorldOriginConfig. const HelloWorldOriginConfig_TypeID = 0x8891f360e47c30d3 func NewHelloWorldOriginConfig(s *capnp.Segment) (HelloWorldOriginConfig, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}) return HelloWorldOriginConfig{st}, err } func NewRootHelloWorldOriginConfig(s *capnp.Segment) (HelloWorldOriginConfig, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}) return HelloWorldOriginConfig{st}, err } func ReadRootHelloWorldOriginConfig(msg *capnp.Message) (HelloWorldOriginConfig, error) { root, err := msg.RootPtr() return HelloWorldOriginConfig{root.Struct()}, err } func (s HelloWorldOriginConfig) String() string { str, _ := text.Marshal(0x8891f360e47c30d3, s.Struct) return str } // HelloWorldOriginConfig_List is a list of HelloWorldOriginConfig. type HelloWorldOriginConfig_List struct{ capnp.List } // NewHelloWorldOriginConfig creates a new list of HelloWorldOriginConfig. func NewHelloWorldOriginConfig_List(s *capnp.Segment, sz int32) (HelloWorldOriginConfig_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz) return HelloWorldOriginConfig_List{l}, err } func (s HelloWorldOriginConfig_List) At(i int) HelloWorldOriginConfig { return HelloWorldOriginConfig{s.List.Struct(i)} } func (s HelloWorldOriginConfig_List) Set(i int, v HelloWorldOriginConfig) error { return s.List.SetStruct(i, v.Struct) } func (s HelloWorldOriginConfig_List) String() string { str, _ := text.MarshalList(0x8891f360e47c30d3, s.List) return str } // HelloWorldOriginConfig_Promise is a wrapper for a HelloWorldOriginConfig promised by a client call. type HelloWorldOriginConfig_Promise struct{ *capnp.Pipeline } func (p HelloWorldOriginConfig_Promise) Struct() (HelloWorldOriginConfig, error) { s, err := p.Pipeline.Struct() return HelloWorldOriginConfig{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) } func (s Tag_List) String() string { str, _ := text.MarshalList(0xcbd96442ae3bb01a, s.List) return str } // 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) } func (s ServerInfo_List) String() string { str, _ := text.MarshalList(0xf2c68e2547ec3866, s.List) return str } // 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 UseConfigurationResult struct{ capnp.Struct } // UseConfigurationResult_TypeID is the unique identifier for the type UseConfigurationResult. const UseConfigurationResult_TypeID = 0xd58a254e7a792b87 func NewUseConfigurationResult(s *capnp.Segment) (UseConfigurationResult, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}) return UseConfigurationResult{st}, err } func NewRootUseConfigurationResult(s *capnp.Segment) (UseConfigurationResult, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}) return UseConfigurationResult{st}, err } func ReadRootUseConfigurationResult(msg *capnp.Message) (UseConfigurationResult, error) { root, err := msg.RootPtr() return UseConfigurationResult{root.Struct()}, err } func (s UseConfigurationResult) String() string { str, _ := text.Marshal(0xd58a254e7a792b87, s.Struct) return str } func (s UseConfigurationResult) Success() bool { return s.Struct.Bit(0) } func (s UseConfigurationResult) SetSuccess(v bool) { s.Struct.SetBit(0, v) } func (s UseConfigurationResult) FailedConfigs() (FailedConfig_List, error) { p, err := s.Struct.Ptr(0) return FailedConfig_List{List: p.List()}, err } func (s UseConfigurationResult) HasFailedConfigs() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s UseConfigurationResult) SetFailedConfigs(v FailedConfig_List) error { return s.Struct.SetPtr(0, v.List.ToPtr()) } // NewFailedConfigs sets the failedConfigs field to a newly // allocated FailedConfig_List, preferring placement in s's segment. func (s UseConfigurationResult) NewFailedConfigs(n int32) (FailedConfig_List, error) { l, err := NewFailedConfig_List(s.Struct.Segment(), n) if err != nil { return FailedConfig_List{}, err } err = s.Struct.SetPtr(0, l.List.ToPtr()) return l, err } // UseConfigurationResult_List is a list of UseConfigurationResult. type UseConfigurationResult_List struct{ capnp.List } // NewUseConfigurationResult creates a new list of UseConfigurationResult. func NewUseConfigurationResult_List(s *capnp.Segment, sz int32) (UseConfigurationResult_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz) return UseConfigurationResult_List{l}, err } func (s UseConfigurationResult_List) At(i int) UseConfigurationResult { return UseConfigurationResult{s.List.Struct(i)} } func (s UseConfigurationResult_List) Set(i int, v UseConfigurationResult) error { return s.List.SetStruct(i, v.Struct) } func (s UseConfigurationResult_List) String() string { str, _ := text.MarshalList(0xd58a254e7a792b87, s.List) return str } // UseConfigurationResult_Promise is a wrapper for a UseConfigurationResult promised by a client call. type UseConfigurationResult_Promise struct{ *capnp.Pipeline } func (p UseConfigurationResult_Promise) Struct() (UseConfigurationResult, error) { s, err := p.Pipeline.Struct() return UseConfigurationResult{s}, err } type FailedConfig struct{ capnp.Struct } type FailedConfig_config FailedConfig type FailedConfig_config_Which uint16 const ( FailedConfig_config_Which_supervisor FailedConfig_config_Which = 0 FailedConfig_config_Which_edgeConnection FailedConfig_config_Which = 1 FailedConfig_config_Which_doh FailedConfig_config_Which = 2 FailedConfig_config_Which_reverseProxy FailedConfig_config_Which = 3 ) func (w FailedConfig_config_Which) String() string { const s = "supervisoredgeConnectiondohreverseProxy" switch w { case FailedConfig_config_Which_supervisor: return s[0:10] case FailedConfig_config_Which_edgeConnection: return s[10:24] case FailedConfig_config_Which_doh: return s[24:27] case FailedConfig_config_Which_reverseProxy: return s[27:39] } return "FailedConfig_config_Which(" + strconv.FormatUint(uint64(w), 10) + ")" } // FailedConfig_TypeID is the unique identifier for the type FailedConfig. const FailedConfig_TypeID = 0xea20b390b257d1a5 func NewFailedConfig(s *capnp.Segment) (FailedConfig, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}) return FailedConfig{st}, err } func NewRootFailedConfig(s *capnp.Segment) (FailedConfig, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}) return FailedConfig{st}, err } func ReadRootFailedConfig(msg *capnp.Message) (FailedConfig, error) { root, err := msg.RootPtr() return FailedConfig{root.Struct()}, err } func (s FailedConfig) String() string { str, _ := text.Marshal(0xea20b390b257d1a5, s.Struct) return str } func (s FailedConfig) Config() FailedConfig_config { return FailedConfig_config(s) } func (s FailedConfig_config) Which() FailedConfig_config_Which { return FailedConfig_config_Which(s.Struct.Uint16(0)) } func (s FailedConfig_config) Supervisor() (SupervisorConfig, error) { if s.Struct.Uint16(0) != 0 { panic("Which() != supervisor") } p, err := s.Struct.Ptr(0) return SupervisorConfig{Struct: p.Struct()}, err } func (s FailedConfig_config) HasSupervisor() bool { if s.Struct.Uint16(0) != 0 { return false } p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s FailedConfig_config) SetSupervisor(v SupervisorConfig) error { s.Struct.SetUint16(0, 0) return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewSupervisor sets the supervisor field to a newly // allocated SupervisorConfig struct, preferring placement in s's segment. func (s FailedConfig_config) NewSupervisor() (SupervisorConfig, error) { s.Struct.SetUint16(0, 0) ss, err := NewSupervisorConfig(s.Struct.Segment()) if err != nil { return SupervisorConfig{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } func (s FailedConfig_config) EdgeConnection() (EdgeConnectionConfig, error) { if s.Struct.Uint16(0) != 1 { panic("Which() != edgeConnection") } p, err := s.Struct.Ptr(0) return EdgeConnectionConfig{Struct: p.Struct()}, err } func (s FailedConfig_config) HasEdgeConnection() bool { if s.Struct.Uint16(0) != 1 { return false } p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s FailedConfig_config) SetEdgeConnection(v EdgeConnectionConfig) error { s.Struct.SetUint16(0, 1) return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewEdgeConnection sets the edgeConnection field to a newly // allocated EdgeConnectionConfig struct, preferring placement in s's segment. func (s FailedConfig_config) NewEdgeConnection() (EdgeConnectionConfig, error) { s.Struct.SetUint16(0, 1) ss, err := NewEdgeConnectionConfig(s.Struct.Segment()) if err != nil { return EdgeConnectionConfig{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } func (s FailedConfig_config) Doh() (DoHProxyConfig, error) { if s.Struct.Uint16(0) != 2 { panic("Which() != doh") } p, err := s.Struct.Ptr(0) return DoHProxyConfig{Struct: p.Struct()}, err } func (s FailedConfig_config) HasDoh() bool { if s.Struct.Uint16(0) != 2 { return false } p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s FailedConfig_config) SetDoh(v DoHProxyConfig) error { s.Struct.SetUint16(0, 2) return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewDoh sets the doh field to a newly // allocated DoHProxyConfig struct, preferring placement in s's segment. func (s FailedConfig_config) NewDoh() (DoHProxyConfig, error) { s.Struct.SetUint16(0, 2) ss, err := NewDoHProxyConfig(s.Struct.Segment()) if err != nil { return DoHProxyConfig{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } func (s FailedConfig_config) ReverseProxy() (ReverseProxyConfig, error) { if s.Struct.Uint16(0) != 3 { panic("Which() != reverseProxy") } p, err := s.Struct.Ptr(0) return ReverseProxyConfig{Struct: p.Struct()}, err } func (s FailedConfig_config) HasReverseProxy() bool { if s.Struct.Uint16(0) != 3 { return false } p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s FailedConfig_config) SetReverseProxy(v ReverseProxyConfig) error { s.Struct.SetUint16(0, 3) return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewReverseProxy sets the reverseProxy field to a newly // allocated ReverseProxyConfig struct, preferring placement in s's segment. func (s FailedConfig_config) NewReverseProxy() (ReverseProxyConfig, error) { s.Struct.SetUint16(0, 3) ss, err := NewReverseProxyConfig(s.Struct.Segment()) if err != nil { return ReverseProxyConfig{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } func (s FailedConfig) Reason() (string, error) { p, err := s.Struct.Ptr(1) return p.Text(), err } func (s FailedConfig) HasReason() bool { p, err := s.Struct.Ptr(1) return p.IsValid() || err != nil } func (s FailedConfig) ReasonBytes() ([]byte, error) { p, err := s.Struct.Ptr(1) return p.TextBytes(), err } func (s FailedConfig) SetReason(v string) error { return s.Struct.SetText(1, v) } // FailedConfig_List is a list of FailedConfig. type FailedConfig_List struct{ capnp.List } // NewFailedConfig creates a new list of FailedConfig. func NewFailedConfig_List(s *capnp.Segment, sz int32) (FailedConfig_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz) return FailedConfig_List{l}, err } func (s FailedConfig_List) At(i int) FailedConfig { return FailedConfig{s.List.Struct(i)} } func (s FailedConfig_List) Set(i int, v FailedConfig) error { return s.List.SetStruct(i, v.Struct) } func (s FailedConfig_List) String() string { str, _ := text.MarshalList(0xea20b390b257d1a5, s.List) return str } // FailedConfig_Promise is a wrapper for a FailedConfig promised by a client call. type FailedConfig_Promise struct{ *capnp.Pipeline } func (p FailedConfig_Promise) Struct() (FailedConfig, error) { s, err := p.Pipeline.Struct() return FailedConfig{s}, err } func (p FailedConfig_Promise) Config() FailedConfig_config_Promise { return FailedConfig_config_Promise{p.Pipeline} } // FailedConfig_config_Promise is a wrapper for a FailedConfig_config promised by a client call. type FailedConfig_config_Promise struct{ *capnp.Pipeline } func (p FailedConfig_config_Promise) Struct() (FailedConfig_config, error) { s, err := p.Pipeline.Struct() return FailedConfig_config{s}, err } func (p FailedConfig_config_Promise) Supervisor() SupervisorConfig_Promise { return SupervisorConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } func (p FailedConfig_config_Promise) EdgeConnection() EdgeConnectionConfig_Promise { return EdgeConnectionConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } func (p FailedConfig_config_Promise) Doh() DoHProxyConfig_Promise { return DoHProxyConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } func (p FailedConfig_config_Promise) ReverseProxy() ReverseProxyConfig_Promise { return ReverseProxyConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } 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))} } func (c TunnelServer) Connect(ctx context.Context, params func(TunnelServer_connect_Params) error, opts ...capnp.CallOption) TunnelServer_connect_Results_Promise { if c.Client == nil { return TunnelServer_connect_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))} } call := &capnp.Call{ Ctx: ctx, Method: capnp.Method{ InterfaceID: 0xea58385c65416035, MethodID: 3, InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer", MethodName: "connect", }, Options: capnp.NewCallOptions(opts), } if params != nil { call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1} call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_connect_Params{Struct: s}) } } return TunnelServer_connect_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 Connect(TunnelServer_connect) 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, 4) } 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}, }) methods = append(methods, server.Method{ Method: capnp.Method{ InterfaceID: 0xea58385c65416035, MethodID: 3, InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer", MethodName: "connect", }, Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error { call := TunnelServer_connect{c, opts, TunnelServer_connect_Params{Struct: p}, TunnelServer_connect_Results{Struct: r}} return s.Connect(call) }, ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1}, }) 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 } // TunnelServer_connect holds the arguments for a server call to TunnelServer.connect. type TunnelServer_connect struct { Ctx context.Context Options capnp.CallOptions Params TunnelServer_connect_Params Results TunnelServer_connect_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) } func (s TunnelServer_registerTunnel_Params_List) String() string { str, _ := text.MarshalList(0xb70431c0dc014915, s.List) return str } // 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) } func (s TunnelServer_registerTunnel_Results_List) String() string { str, _ := text.MarshalList(0xf2c122394f447e8e, s.List) return str } // 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) } func (s TunnelServer_getServerInfo_Params_List) String() string { str, _ := text.MarshalList(0xdc3ed6801961e502, s.List) return str } // 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) } func (s TunnelServer_getServerInfo_Results_List) String() string { str, _ := text.MarshalList(0xe3e37d096a5b564e, s.List) return str } // 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) } func (s TunnelServer_unregisterTunnel_Params_List) String() string { str, _ := text.MarshalList(0x9b87b390babc2ccf, s.List) return str } // 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) } func (s TunnelServer_unregisterTunnel_Results_List) String() string { str, _ := text.MarshalList(0xa29a916d4ebdd894, s.List) return str } // 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 } type TunnelServer_connect_Params struct{ capnp.Struct } // TunnelServer_connect_Params_TypeID is the unique identifier for the type TunnelServer_connect_Params. const TunnelServer_connect_Params_TypeID = 0xa766b24d4fe5da35 func NewTunnelServer_connect_Params(s *capnp.Segment) (TunnelServer_connect_Params, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return TunnelServer_connect_Params{st}, err } func NewRootTunnelServer_connect_Params(s *capnp.Segment) (TunnelServer_connect_Params, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return TunnelServer_connect_Params{st}, err } func ReadRootTunnelServer_connect_Params(msg *capnp.Message) (TunnelServer_connect_Params, error) { root, err := msg.RootPtr() return TunnelServer_connect_Params{root.Struct()}, err } func (s TunnelServer_connect_Params) String() string { str, _ := text.Marshal(0xa766b24d4fe5da35, s.Struct) return str } func (s TunnelServer_connect_Params) Parameters() (CapnpConnectParameters, error) { p, err := s.Struct.Ptr(0) return CapnpConnectParameters{Struct: p.Struct()}, err } func (s TunnelServer_connect_Params) HasParameters() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s TunnelServer_connect_Params) SetParameters(v CapnpConnectParameters) error { return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewParameters sets the parameters field to a newly // allocated CapnpConnectParameters struct, preferring placement in s's segment. func (s TunnelServer_connect_Params) NewParameters() (CapnpConnectParameters, error) { ss, err := NewCapnpConnectParameters(s.Struct.Segment()) if err != nil { return CapnpConnectParameters{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } // TunnelServer_connect_Params_List is a list of TunnelServer_connect_Params. type TunnelServer_connect_Params_List struct{ capnp.List } // NewTunnelServer_connect_Params creates a new list of TunnelServer_connect_Params. func NewTunnelServer_connect_Params_List(s *capnp.Segment, sz int32) (TunnelServer_connect_Params_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) return TunnelServer_connect_Params_List{l}, err } func (s TunnelServer_connect_Params_List) At(i int) TunnelServer_connect_Params { return TunnelServer_connect_Params{s.List.Struct(i)} } func (s TunnelServer_connect_Params_List) Set(i int, v TunnelServer_connect_Params) error { return s.List.SetStruct(i, v.Struct) } func (s TunnelServer_connect_Params_List) String() string { str, _ := text.MarshalList(0xa766b24d4fe5da35, s.List) return str } // TunnelServer_connect_Params_Promise is a wrapper for a TunnelServer_connect_Params promised by a client call. type TunnelServer_connect_Params_Promise struct{ *capnp.Pipeline } func (p TunnelServer_connect_Params_Promise) Struct() (TunnelServer_connect_Params, error) { s, err := p.Pipeline.Struct() return TunnelServer_connect_Params{s}, err } func (p TunnelServer_connect_Params_Promise) Parameters() CapnpConnectParameters_Promise { return CapnpConnectParameters_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } type TunnelServer_connect_Results struct{ capnp.Struct } // TunnelServer_connect_Results_TypeID is the unique identifier for the type TunnelServer_connect_Results. const TunnelServer_connect_Results_TypeID = 0xfeac5c8f4899ef7c func NewTunnelServer_connect_Results(s *capnp.Segment) (TunnelServer_connect_Results, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return TunnelServer_connect_Results{st}, err } func NewRootTunnelServer_connect_Results(s *capnp.Segment) (TunnelServer_connect_Results, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return TunnelServer_connect_Results{st}, err } func ReadRootTunnelServer_connect_Results(msg *capnp.Message) (TunnelServer_connect_Results, error) { root, err := msg.RootPtr() return TunnelServer_connect_Results{root.Struct()}, err } func (s TunnelServer_connect_Results) String() string { str, _ := text.Marshal(0xfeac5c8f4899ef7c, s.Struct) return str } func (s TunnelServer_connect_Results) Result() (ConnectResult, error) { p, err := s.Struct.Ptr(0) return ConnectResult{Struct: p.Struct()}, err } func (s TunnelServer_connect_Results) HasResult() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s TunnelServer_connect_Results) SetResult(v ConnectResult) error { return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewResult sets the result field to a newly // allocated ConnectResult struct, preferring placement in s's segment. func (s TunnelServer_connect_Results) NewResult() (ConnectResult, error) { ss, err := NewConnectResult(s.Struct.Segment()) if err != nil { return ConnectResult{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } // TunnelServer_connect_Results_List is a list of TunnelServer_connect_Results. type TunnelServer_connect_Results_List struct{ capnp.List } // NewTunnelServer_connect_Results creates a new list of TunnelServer_connect_Results. func NewTunnelServer_connect_Results_List(s *capnp.Segment, sz int32) (TunnelServer_connect_Results_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) return TunnelServer_connect_Results_List{l}, err } func (s TunnelServer_connect_Results_List) At(i int) TunnelServer_connect_Results { return TunnelServer_connect_Results{s.List.Struct(i)} } func (s TunnelServer_connect_Results_List) Set(i int, v TunnelServer_connect_Results) error { return s.List.SetStruct(i, v.Struct) } func (s TunnelServer_connect_Results_List) String() string { str, _ := text.MarshalList(0xfeac5c8f4899ef7c, s.List) return str } // TunnelServer_connect_Results_Promise is a wrapper for a TunnelServer_connect_Results promised by a client call. type TunnelServer_connect_Results_Promise struct{ *capnp.Pipeline } func (p TunnelServer_connect_Results_Promise) Struct() (TunnelServer_connect_Results, error) { s, err := p.Pipeline.Struct() return TunnelServer_connect_Results{s}, err } func (p TunnelServer_connect_Results_Promise) Result() ConnectResult_Promise { return ConnectResult_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } type ClientService struct{ Client capnp.Client } // ClientService_TypeID is the unique identifier for the type ClientService. const ClientService_TypeID = 0xf143a395ed8b3133 func (c ClientService) UseConfiguration(ctx context.Context, params func(ClientService_useConfiguration_Params) error, opts ...capnp.CallOption) ClientService_useConfiguration_Results_Promise { if c.Client == nil { return ClientService_useConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))} } call := &capnp.Call{ Ctx: ctx, Method: capnp.Method{ InterfaceID: 0xf143a395ed8b3133, MethodID: 0, InterfaceName: "tunnelrpc/tunnelrpc.capnp:ClientService", MethodName: "useConfiguration", }, Options: capnp.NewCallOptions(opts), } if params != nil { call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1} call.ParamsFunc = func(s capnp.Struct) error { return params(ClientService_useConfiguration_Params{Struct: s}) } } return ClientService_useConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))} } type ClientService_Server interface { UseConfiguration(ClientService_useConfiguration) error } func ClientService_ServerToClient(s ClientService_Server) ClientService { c, _ := s.(server.Closer) return ClientService{Client: server.New(ClientService_Methods(nil, s), c)} } func ClientService_Methods(methods []server.Method, s ClientService_Server) []server.Method { if cap(methods) == 0 { methods = make([]server.Method, 0, 1) } methods = append(methods, server.Method{ Method: capnp.Method{ InterfaceID: 0xf143a395ed8b3133, MethodID: 0, InterfaceName: "tunnelrpc/tunnelrpc.capnp:ClientService", MethodName: "useConfiguration", }, Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error { call := ClientService_useConfiguration{c, opts, ClientService_useConfiguration_Params{Struct: p}, ClientService_useConfiguration_Results{Struct: r}} return s.UseConfiguration(call) }, ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1}, }) return methods } // ClientService_useConfiguration holds the arguments for a server call to ClientService.useConfiguration. type ClientService_useConfiguration struct { Ctx context.Context Options capnp.CallOptions Params ClientService_useConfiguration_Params Results ClientService_useConfiguration_Results } type ClientService_useConfiguration_Params struct{ capnp.Struct } // ClientService_useConfiguration_Params_TypeID is the unique identifier for the type ClientService_useConfiguration_Params. const ClientService_useConfiguration_Params_TypeID = 0xb9d4ef45c2b5fc5b func NewClientService_useConfiguration_Params(s *capnp.Segment) (ClientService_useConfiguration_Params, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return ClientService_useConfiguration_Params{st}, err } func NewRootClientService_useConfiguration_Params(s *capnp.Segment) (ClientService_useConfiguration_Params, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return ClientService_useConfiguration_Params{st}, err } func ReadRootClientService_useConfiguration_Params(msg *capnp.Message) (ClientService_useConfiguration_Params, error) { root, err := msg.RootPtr() return ClientService_useConfiguration_Params{root.Struct()}, err } func (s ClientService_useConfiguration_Params) String() string { str, _ := text.Marshal(0xb9d4ef45c2b5fc5b, s.Struct) return str } func (s ClientService_useConfiguration_Params) ClientServiceConfig() (ClientConfig, error) { p, err := s.Struct.Ptr(0) return ClientConfig{Struct: p.Struct()}, err } func (s ClientService_useConfiguration_Params) HasClientServiceConfig() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s ClientService_useConfiguration_Params) SetClientServiceConfig(v ClientConfig) error { return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewClientServiceConfig sets the clientServiceConfig field to a newly // allocated ClientConfig struct, preferring placement in s's segment. func (s ClientService_useConfiguration_Params) NewClientServiceConfig() (ClientConfig, error) { ss, err := NewClientConfig(s.Struct.Segment()) if err != nil { return ClientConfig{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } // ClientService_useConfiguration_Params_List is a list of ClientService_useConfiguration_Params. type ClientService_useConfiguration_Params_List struct{ capnp.List } // NewClientService_useConfiguration_Params creates a new list of ClientService_useConfiguration_Params. func NewClientService_useConfiguration_Params_List(s *capnp.Segment, sz int32) (ClientService_useConfiguration_Params_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) return ClientService_useConfiguration_Params_List{l}, err } func (s ClientService_useConfiguration_Params_List) At(i int) ClientService_useConfiguration_Params { return ClientService_useConfiguration_Params{s.List.Struct(i)} } func (s ClientService_useConfiguration_Params_List) Set(i int, v ClientService_useConfiguration_Params) error { return s.List.SetStruct(i, v.Struct) } func (s ClientService_useConfiguration_Params_List) String() string { str, _ := text.MarshalList(0xb9d4ef45c2b5fc5b, s.List) return str } // ClientService_useConfiguration_Params_Promise is a wrapper for a ClientService_useConfiguration_Params promised by a client call. type ClientService_useConfiguration_Params_Promise struct{ *capnp.Pipeline } func (p ClientService_useConfiguration_Params_Promise) Struct() (ClientService_useConfiguration_Params, error) { s, err := p.Pipeline.Struct() return ClientService_useConfiguration_Params{s}, err } func (p ClientService_useConfiguration_Params_Promise) ClientServiceConfig() ClientConfig_Promise { return ClientConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } type ClientService_useConfiguration_Results struct{ capnp.Struct } // ClientService_useConfiguration_Results_TypeID is the unique identifier for the type ClientService_useConfiguration_Results. const ClientService_useConfiguration_Results_TypeID = 0x91f7a001ca145b9d func NewClientService_useConfiguration_Results(s *capnp.Segment) (ClientService_useConfiguration_Results, error) { st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return ClientService_useConfiguration_Results{st}, err } func NewRootClientService_useConfiguration_Results(s *capnp.Segment) (ClientService_useConfiguration_Results, error) { st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) return ClientService_useConfiguration_Results{st}, err } func ReadRootClientService_useConfiguration_Results(msg *capnp.Message) (ClientService_useConfiguration_Results, error) { root, err := msg.RootPtr() return ClientService_useConfiguration_Results{root.Struct()}, err } func (s ClientService_useConfiguration_Results) String() string { str, _ := text.Marshal(0x91f7a001ca145b9d, s.Struct) return str } func (s ClientService_useConfiguration_Results) Result() (UseConfigurationResult, error) { p, err := s.Struct.Ptr(0) return UseConfigurationResult{Struct: p.Struct()}, err } func (s ClientService_useConfiguration_Results) HasResult() bool { p, err := s.Struct.Ptr(0) return p.IsValid() || err != nil } func (s ClientService_useConfiguration_Results) SetResult(v UseConfigurationResult) error { return s.Struct.SetPtr(0, v.Struct.ToPtr()) } // NewResult sets the result field to a newly // allocated UseConfigurationResult struct, preferring placement in s's segment. func (s ClientService_useConfiguration_Results) NewResult() (UseConfigurationResult, error) { ss, err := NewUseConfigurationResult(s.Struct.Segment()) if err != nil { return UseConfigurationResult{}, err } err = s.Struct.SetPtr(0, ss.Struct.ToPtr()) return ss, err } // ClientService_useConfiguration_Results_List is a list of ClientService_useConfiguration_Results. type ClientService_useConfiguration_Results_List struct{ capnp.List } // NewClientService_useConfiguration_Results creates a new list of ClientService_useConfiguration_Results. func NewClientService_useConfiguration_Results_List(s *capnp.Segment, sz int32) (ClientService_useConfiguration_Results_List, error) { l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) return ClientService_useConfiguration_Results_List{l}, err } func (s ClientService_useConfiguration_Results_List) At(i int) ClientService_useConfiguration_Results { return ClientService_useConfiguration_Results{s.List.Struct(i)} } func (s ClientService_useConfiguration_Results_List) Set(i int, v ClientService_useConfiguration_Results) error { return s.List.SetStruct(i, v.Struct) } func (s ClientService_useConfiguration_Results_List) String() string { str, _ := text.MarshalList(0x91f7a001ca145b9d, s.List) return str } // ClientService_useConfiguration_Results_Promise is a wrapper for a ClientService_useConfiguration_Results promised by a client call. type ClientService_useConfiguration_Results_Promise struct{ *capnp.Pipeline } func (p ClientService_useConfiguration_Results_Promise) Struct() (ClientService_useConfiguration_Results, error) { s, err := p.Pipeline.Struct() return ClientService_useConfiguration_Results{s}, err } func (p ClientService_useConfiguration_Results_Promise) Result() UseConfigurationResult_Promise { return UseConfigurationResult_Promise{Pipeline: p.Pipeline.GetPipeline(0)} } const schema_db8274f9144abc7e = "x\xda\xacY\x7f\x8c\x1c\xf5u\x7fo\xbe\xbb;>s" + "\xe7\xdd\xf1\x1c\xe0;\x8c\xb6\xb2\x88\x12\x13L!.m" + "\xb8VY\xdf\x9d\xcf\xb9u\xfcc\xe7\xf6\xce\x801\x92" + "\xc7\xbb\xdf\xdb\x9b\xf3\xec\xccz~\x98;\xcb\xc4`\xd9" + "\x05_q\xb0\x09\x960\xc1\x11\xb8q\xc1\xc8\x14L\x8c" + "Z(I\x93\xaa-\xa1IE\xdaB\x95\xb4\xf9\xa3\x0d" + "\xa0*\xa8\x115I\x85R\x05\xa6z\xf3\xfb\xf66g" + "\xbb\xea?\xf6\xe8\xed\xf7\xc7\xfb~\xde{\x9f\xf7\xe3n" + "y}\xc9:\xe1\xd6\xec_v\x03(\x8fes\xde\x1f" + "4\xdf<\xfd\xbb'\xbe\x7f\x08\xa4~\xc1\xfb\xf2k\x1b" + "{\x7f\xe5\x1c\xfcW\x00\\;\x92\xdb\x87\xf2]9\x11" + "@\x9e\xc8m\x05\xf4\xfe\xe9\x96\xfd\xef\xee\xfc\xc5\xf1\x87" + "@\xea\xc7deF\x04X\xdb\xcc\xcd\xa1|8'\x02" + "\xf3N\xdd\xdd\xfbw\xf8\xd4G\xc7A\xfa\x0c\x02d\x91" + "~VsK\x05@y6W\x02\xf4\xde\xbc\xe9\xb5W" + "\x8f}\xf3\xc1\xaf\x81\xf2iD\x08\xf6\x9f\xcc\xfd\x0f\x02" + "\xca\xcf\xfb\x0b.~\xe3\xb3\x99\xe7\xdf\\\xfeu\x7f\x81" + "w\xe6\x1f\xeex\xe9\xd87\x7f\xeb}\x98\x10D\xcc\x00" + "\xac};g\xd1\xda\x7f\xcf\xfd\x07\xa0\xf7\xd8\x8f\xbe\xb5" + "\xa5y\xfc\x89\xd3 }::\xeb\xbb\xa2 @\xc6\xbb" + "\xed_\xde\xdb\xba\xf9\xa5\xc9g\x82_\x02=^\x16_" + "\xa2\xad\x7f#\xd25\xdf\xbb\xb7\xf0\xf0\xe0\xef=\xf2\x0c" + "(\xfd\x98zO6K+\x7f&\xce\xa1\x8cK\xe8\xf3" + "c\xf1\x0e\x04\xf4\xe6n\xff\xd6\xb6_\xfc\xa1\xfd\x1c(" + "k0\xe3\xfd\xf5\x91w\xf6\xae>;\xf9\xba\xaf\x15\x03" + "X\xebv\xfd#\x1d}\xa4\xeb\x05@\xaf\xe7/n\xdc" + "\xf2\xc8\xbb\x9b\xce\xd3\xd1)P\x03%V/\x1d@\xf9" + "\xf6\xa5\x84\xebmKi\xf5\x0fo\xda\xf6\xedo\xbf\xd8" + "8\xdf\xae\x88@\xab\xdf^\xba\x11\xe5\x9f\xf9\xab\xdf\xf3" + "W_]\xc6\x9f|\xe7\xd6\xcc\x9f\x85\xefb>|W" + "\xbd\xef\xc3w\x15-\xb8\xfb\xd7/\xff\xd5\xc8\x07o\xbd" + "\x926\xc0\xe6n\x81\x0c\xa0v\xd3\xc3\xaf\xff\xf9P\x8f" + "\xf1\xc1\xc1\xef\xcc\xb7cp\xd2\x91\xee\x8d(\x9f\xea\xa6" + "\xebNv\xbf\x00\xf8\xd1s\x0f\x1e+\xbf\xb3\xfeu\xa5" + "\x1f3\xed\x0f\xb9\xadg\x1f\xca\xe5\x1e\xfa\x1c\xe9)\x12" + "F1*m\xcb\xfd\x97\xb8\xcb\xa6Q>\xb2\x8c>\x0f" + "/\xf3\x97o\xbc\xfb\xab\x8ff\xdf\xfb\xea\xeb\xed0\x89" + "\xb4\xe6x\xdeB\xf9L\x9e>\x9f\xce?#\x00z\xfd" + "/\xfe\xfe\x9f\x0e\xd5\x7f\xfc\xfd6\xbd\xe9p\xf9\xe8\xf2" + "\x0f\xe5\x93\xcb\xe9\xeb\xc4\xf2{\x01\xbd\x07?;\xbbo" + "\xcb\xa7\xe6\xden\xc7\xd4W\xfc\xe2\xf29\x94\xbbdZ" + "\x9d\x95i\xb5\xf0\x9e\xdaw\xff?\x7f\xe1')/r" + "\xe5\x9f\"d\xbc-\xdb\xee\x9e\xee\xba\xef\x9dw\xd2^" + "\xa4\xc9>\xda\xf7\xc9\x04\xe6\x05\xe9Q\xf9\xb5\xa7\xff\xe4" + "]\xbaHlG\xf3\x94\xbc\x1d\xe5\xf3t\xd1\xda\xe7e" + "\xff\x0d\xb17w\xb2\xf5\xd9k\x06P~\xe5\x1a\xd2\xeb" + "\xe5kH\xaf\xdbv\x0e\xf2\x1d\x9f\xbf\xf3}\x90\xfa\xd9" + "\xbc\xd8\xfcoZ\x99\xbd\x966\xe1\xb5\"\xca\xe7\xe9\xd3" + "\xfbJc\xfb\x1b\x17\x87\x9f\xfe\xaf\xf6\xc3\x83\x10\xbbv" + "\x00\xe5\xb3\xfe\x963\xd7\xfa\xf0\xaf\xbd\xf5\x8f~~\xe2" + "\x8f\x87/.8\xfd\xe2\x8a!\x94\xb1\x8f\xf4\xf8x\xc5" + "\x17\xe55}\xfe\xe1_^\xbf\xf5\xf6U\xdf\xfd0\x8d" + "\xc4\xd5}\x1f\x12\x12\xab\xfb\x08\x89\xc9\xcf\xff\xe7\x17?" + "\xf5\x95\xbf\xfd\xb0\xcd<\xfe\xc2r\xdf\x8d(\xdf\xe5\x9f" + "8A\x8b?\xd8\xf0\xf5\xb7\xfa\xf3\xfd\xbf\xec\xa4\xe8l" + "\xdf4\xcaG\xfb|o\xec\xf3\x15\xbd\xf3\xa7O\xdc[" + "\xfa\xda/?\xa2w\xb16\xe6y\xa5\x7f;\xca\x7f\xdf" + "O'\xbf\xd1O\xee\xbf\xe9\xdc\x8f\xbf0u\xe2{\xbf" + "j\x07\xc17\x88{\xddA\x94\x8f\\G\xab\x0f_G" + "\xfc\xb1\xff\x83\x93\xa3\x8f\xec8\xf7I\xfaU\xcd\x95\xaf" + "\xfa\xf6]I\xaf\x9a>\xb1\xdf\x19}\xfc\xa8\xd7)X" + "N\xad\x1cB\xf9\xf9\x95t\xda\xd9\x95/\xc0\x1a\xcfq" + "\x0d\x83\xebV+S\xfb\xed\xe8\xb3vsMm\x19\xad" + "\x81\x91\x19\xcdv4\xa31\xee\xcbK\x15S\xd7j\xb3" + "\x15D\xa5\x1b\x05\x00\xe9\xfa\x01\x00D\xe9\xea\xed\x00(" + "H\xd2\x10@Ik\x18\xa6\xc5\xbd\xbaf\xd7L\xc3\xe0" + "\xc0j\xce\x81]\xaa\xae\x1a5\x1e_\x94]x\xd1(" + "\xd7u\xf3\x0e\xd3\xd2\xeb[-\xad\xa1\x19\xc3\xa61\xa9" + "5\x00*\x88\xf16q\xe1\xb6a]\xe3\x86S\xe5\xd6" + "^\xad\xc6ovm\x1e\xecs-\xd5\xd1L\xe3\x861" + "n\xbb\xbac\x03(\x19\x96\x01\xc8 \x80\xd43\x00\xa0" + ",a\xa8\xf4\x0aX\xb2\xfc\x05XH\"\x0f\x10\x0b\x90" + "\xdc\x99[xg\x80\x05\xdd\xc9\xad\x9b]\xc3\xe2\x0d\xcd" + "v\xb8\x15\x88o(UTKm\xda\xe9\x0b\x9f\x00P" + "\x0a\x0c\x95\x95\x02z\x0dK\xad\xf1\x0a\xb7P3\xeb[" + "T\xc3\xac2^\xc3,\x08\x98M]\xda\xc1\x10\x1bT" + "M\xe7\xf5\xe0u7\xd7\x8a\xfe\xffJ\x81e\xba=\xcf" + "\xbfD\xdd\x0e\xa0\xecd\xa8\xe8\x02\xf6\xe0'^/%" + ")I\xdb\x07\xa0L1T\x1c\x01{\x84\x8f\xbd^\xdf" + "j{V\x01(:CeF\xc0\x1e\xf6k\xaf\x97R" + "\x81\xe4N\x03(\x0eC\xe5~\x01=\xdbm\x11\xa66" + "0\xd3\xc2B\xe2\xca!:\xbc\xde \xa4\x0d(\xf1\x1a" + "\x01\x8d\x85\x88q\x83\x05b\xdd\x9c\xc2B\x92\"\xc2m" + "\x16\xdf\xcb-\x9bW o\x993\xb3XH\x98\xb7\x0d" + "\xf5\x9e+E=2t\xbck\xf1\xfd\xbek\xd6\x9c\x1b" + "*\xc5\x05\xc6\"\x1c\xbb\x19*+\x04\xf4Z\xf4+w" + "80\xcb\xc6B\x92z\xdb\xb4\xed\xe0\xce\xc3\xf4\xefp" + "pK%<\xc5\xb2}wVV\xc4\x97\x9d\xa4\xcb\x1e" + "g\xa8|C@\x091\xb0\xd9\xd3\x16\x80\xf2\x14C\xe5" + "\x9c\x80(\x04\x16;{\x1a@9\xc7P\xf9s\x01%" + "&\x04\x06{\xf9F\x00\xe5E\x86\xca\x0f\x04\x942\xac" + "\x97\xca\x0c\xe9\x0dr\xb6\x1f0T~$\xa0\x94\xcd\xf4" + "b\x16@z{\x17\x80\xf2\x16C\xe5\xdf\x04\xf4\xcc " + "\xbe\xe8Q\x0e\xf6\x80\x80=\x80^M7\xdd\xfa\xa4\xae" + "B\xd1\xe2\xf5\xf2\xfaXn\xb8\xcd\x8a\xc5\xf7jh\xba" + "\xf6\xa0\xe3\xf0\xa6\xd8rl\xcc\x81\x809\xc0\xbc\xa36" + "l\\\x06Xa\x88\x85$\xd1\x01\x920>\x13-^" + "\xdf\xc6-[c\xa6\x81\xdd `7\xa0\xa7\x19\x0e7" + "\x9cM*\x88\xbb\xb8\x1eK\x17\x89\xba\xb1\xd0w\xc8s" + "\xc200\x13\xa6\xc0\x86\xd2\xcd2+=/\x04q\x84" + "\xb0Y\xc7P\xd9$\xe0\xf5\xf8\x09\x89\x09\xc7\xf2\x18\x80" + "2\xcaP\x19\x17\xf0z\xe1c\x12\x13\x92\x0a\xd9\xa1\xc2" + "P\xd9!`~\xcaqZXH2dh\xec{\xf9" + ".\xdb\xac\xed\xe6\x80D\x171]\x87\xbfN\x85\xf4\x05" + "L\xafc!\xa99\xdb<\x85u\xf0\x14\xdfIJ\xce" + "\x88e\x99\x96\xcf\xac\xb1{\x8c|.yD\xe4\x1d\xe5" + "\xed\xc9\x0b$a]\xf0,eW\xa2\x7f\xb1\xa6\xba6" + "\x8f\x11\xb5\xb8c\xcd\x0eN:\xc0\xb8\x15\xf3\x8c=e" + "\xbaz}\x8c\x83\xe8X\xb3\x88 .\xce>\xeb\xcd" + "\xd1\x14\xf0\x81\x1b\xa7\xf4$\x9d\xd63T*\x89\x9e\x9b" + "I\xb6\x89\xa1r'\xe9\x19\xc2?A\xf0\x8f3TZ" + "\x02z:\xc5\xaf1j\x02\xb3\x9dX\xdd@X1}" + "\xe7\x14A@\x11\xd0s[\xb6cq\xb5\x09\x18{\x1b" + "\xad_v\x054\xddF\x17\x155\xef\xc7}\xe77\xc4" + "\xa1\xb8yc\xfa\x11a,N\x0c%`w\x0e\xa6)" + "\xd3v\x0c\xb5\xc9\x01 z\xd8\x01\xb3El\x1a\xe2\xa4\xd6\xc0BRo\xb5" + ")\xd0\xc1\xee\x83\xae3\xc5\x0dG\xab\xf9\x17.\xb0\xfb" + "\xaa\xc4?c\xcc\xca\x9fK\x01\x19a\xb6yW\x02\xa4" + "\xb8\x9b\xcfF\xb0\x14yS\xd5\x92\xf0\x0f\xd1\x1c\x04\xf1" + "K\xc9\x9aE\xcb\x930\x0f\x05Y\xa8\x14\xc0CJ\xf6" + "\xc6J\xde7\x07\xa0\xdc\xcfPy8\xa5\xe4\x91G\x01" + "\x94\x87\x19*\x8f\xa7\x94\x1a\xec\x12U\xc7\xc6.\x10\xb0\x8b" + "B\xc0\xe6\xd6\xb0\xc5\xebH\xd6P\xf5\x8a\xca\x9c\xa9\xcb" + "\x01h>k\xe6;\xc0C\x15\xc2~\x86\xcaC\x14\xbb" + "\x98j\x18\xa5\xc3\xd3 \xf8\xa1Ko\xde3\x94\xd4\x0c" + "~\x06\xa2\xbc\xe2\x12\x8c3\x0c\x95Ca\x06\xca\x01H" + "\x0f\x10:\x87\x18*\xc7\x84H\xb5Q\x13JAH\xb4" + "\x9b\xda\x04_\xa7\x03DS\x1aO\xde\x1b&h\x0dM" + "c\xdc\x07\x0a\x13\xa4jf\xb3eq\xdbF\xcd4\x14" + "W\xd55\xe6\xcc\xc6\x1b\x17\xc5\x828 \x88\x9d\xad\xad" + "\xa2o,\x02\xe3\x96\x08\x0cy\x107\x02T\xd7!\xc3" + "\xea&L\xdcE.\xe3\x10@u=\xc9+\x98x\x8c" + "\xbc\x19\xfb\x01\xaa\xa3$\x1fG\x011\xf0\x19Y\xc1\xe7" + "\x00\xaa\xe3$\xde\x89In\x96\xef\xf1\x8f\xdfA\xf2)" + "L\xd2\xb3\xcc\xf1F\x80\xeaN\x92\xef'yN\xf0\x91" + "\x94gq\x1a\xa0:C\xf2C$\x17\xb3\xbdT\xe9\xcb" + "\x0f\xa0\x05P\xbd\x9f\xe4\x0f\x93|\xc9\x8a^\\\x02 " + "\x1f\xf1\xe5\x0f\x91\xfc1\x92w\xf5\xf5b\x17\x80|\x1c" + "\x0f\x02T\x8f\x91\xfcI\x92/\xc5^\\J\xad2>" + "\x01P}\x92\xe4\xcf\x92\xfc\xaa\\/^\x05 \x9f\xf1" + "\xf5y\x8a\xe4\xe70&\x92r=\xcdg\xe4VZ\x92" + "\xcf\x99i\xc7\xa6\xe5a\xcf\x80\x01\xd9V\xcc<5\x0d" + "\x98Of6\x80\x98\x07\xf4Z\xa6\xa9o\x99\xcf\x93\x97" + "*)B\xb7\x80\xbci\x94\xebq\x9c\x05\xce\xb4\xc9\x84" + "bM\xd5\xcb\xad\xa4\xc8\xb0\x07]\xc7t[P\xac\xab" + "\x0e\xaf\xc7\x99\xcer\x8d\x0d\x96\xd9\x1cGn55C" + "\xd5!\xfee1\xdf\xca\xbb\xaeV_\x10tB\xbb\xa3" + "\x15[\x03\xe3\xaa\x1feK\xe2([M\xe5\xc8\x0d\x0c" + "\x95[R$\xb4\x86\x98\xf23\x0c\x95\xdf\x110\x9f\x0e" + "\x8e\xe2^Uw\xf9\x82\x9b:\x94\x99\x13m)!(" + "\x83\x03\x9eN\xdd>\x94\xdc\x1e_NU\xe6M\x0c\x95" + "Q\x01\x0f\xd8n\xadF\x8f\x8eP\x98\x0c\x9b\x0d(\xd2" + "\xd9){\xc4s\x80\xd0\x1e\x97\x9b~\x1b\xdc\x09\xbe\xca" + "\xc6\xa4IyKT\x9b\xf6\xffq\xf7\x18\xb7\xf3T\xeb" + "_\xb2\xa5\x8b;\xfbK\xe7\xb9\xd1\xf1\xf1J\xd2w\xb2" + "\x80$\xd3\xbc0\x96\xe6\x85\x84\x16\xa6\xd3\xe1\x1f\x95c" + "\xb2\xe2\xc7a\x85\xe4;0)\xd8\xe5\xbb\xf0\xf4\xbc\xf8" + "\xcf\x0c\x06\xbc\xc0\xfd\xe3\xeb$o\xf9\xbc\x80\x01/4" + "\xfd\xf3u\x92\xcf\xa4y\xc1\xc5\xb9\xf9\xbc\xc0\"^\xa0" + "x>D\xf2c>/d\x02^8\x8a/\xcd\x8b\xff" + "\xael\xc0\x0b'\xf1\xd5y\xf1\xbf4\x17\xf0\xc2\x19\x7f" + "\xfd\xb3$\xbf\xe0\xf3\xc2P\xc0\x0b\xe7}\x1ey\x91\xe4" + "\xaf\x11/\xb8\x96^u,\xcd\x00l$\xceZk}" + "\x89\xf3\xd6 \xe4um/\x8f9\xbb\xae\xa9\xfazW" + "\xd5\xa1Xu\xd4\xda\xee\xa4\xe6\xd4\xedQ\xd5\xa8\xdb8" + "\xa5\xee\xe6\xc4\xf4b:':\xba\xbd\x8d[\xda$`" + "R\xa5\xc65B\xbeb\x9a\xed\xa5\x83_\xecp+ " + "\x95\xf8\xb7\xa6:S\xae\xeb|\x18\xa3J\x81\x19I\xa6" + "\xd1\xe8\x17\xd300H\xdf\xe3Zq~^n\x85u" + "o\x94\xdf\xc7Km\x89\x9b\xcf\xb4x\xcd\x196\xd1p" + "4\xc3\xe5\x0b\x0e\xa8M\xb9\xc6n^\x1fA\xa3f\xd6" + "5\xa3\x01\x0b\x0an\xf6\x9b\xda\xfdTA\xe3G3\xa6" + "\xa6\xcc\xd2\xea\x01\x10|.\xa1\xf4,\x0d$mk\xa9" + "\xe6\xef*Y\\\xb5S\x1d\xd7\"\xb7\x85\xd3\x9d \xc8" + "\xe8\xb6\x02\xcb\x02\xc43[\x8c\x86h\xd2\x9e} H" + "\x9a\x88\xc9\xec\x11\xa3Q\xa3t\x8f\x05\x824!\xa2\x10" + "\x8f\xca1\x1asK\xe59\x10\xa4\x11\x11Y<\xdf\xc6" + "h\x84%\xdd>\x04\x82\xb4F\xf4\xa2\x12\x1dJ\x81:" + "\xeb\xd0\x8b\x02\x1f\x8a~\xe8\xafC/j\xfc1*\xe5" + "\x01\xd6\xe1\x810-\xac\xc3\xf4\xb4\x88\xfd\xa6z\xbas" + "\x998\x94\x942\x11G>0\x97T2q\x0fs\xf4" + "\xb9t\x95\x18\xb6\xe2'\x0f\x86\x8d\xfc\x85T+~\x9e" + "J\xc7\x0b\x0c\x95\x1f\x0aI\xbe\x8c\xdc.\x1a\xb0\xa0i" + "EM\xd5\"s\x96\xd09\xc3\x0a\xae}\xda\xe2\xd5\xcd" + ")\xbf\xc2\xc3\xe0(\x1b\x12\xc6N\x8f`\x96\xa5F0" + "\x18\xb5s\xe2<\x82O\x0fd\x96-\xce\x99\xf3\x9a\x13" + "?\xe3d|\xaf\x89\x06\xf9\x18\xfdIE\x92\xc8\xfa=" + "\xa2\x1750\x18\xa5+2^\xdadW\xd8\xc5\x8d\xf1" + "\xa2}9\x99 \x1a\xdb^\xba\x19\x0f\xee\xc9\x93\xb3\x05" + "\x0f\x8a\xcf\x9dN\x8d\x85t3\xec\x87\xf2[\xd2%\xed" + "\"X\x05\x0aG\x05h\x9e6\xb7\xb9\xdf\xaaT%\x1d" + "\xfb\xdf\xaa\xa46\x8f\xbb\x94\xc3\x1bC\xa7|*.8" + "\xa5Ss\xc9\xc8(v\xbf\xb3\x1b\x93.E\xe4\x96\x15" + "\xe9)\xbaVB\x9b\xba\xd9\xd8\xa4\x19\xdc\xa6\x12\xac\xad" + "\xb5nq\xab\xa9\x1a\xdc@\x87\xc8\xc8\xb5\x88Q\xe73" + "Wy}\xaar[\xec\xf9\xd5\xd0\xd9\x03_\x0f\xd3k" + "\xaa\x8f<\x9d\x9aiD\x8fW^\x0dg\x05;S\x8f" + "\xbf\x87\xfa\xc8\x1d\x0c\x95)\x01=\xd5u\xcc\x89V]" + "E\x87o\xb0\xf8\x1e\x97\x8bFm6\xe9\xa7\xa8\xa3\xa8" + "\xd9\x13\xd8\xa2\xdao\x83\xc5K{\\\x9e^\x10Mb" + "A\xd4\xcc\xfa\x82\x11l\x87b\xeb\x0e\xbe\xabj\xd6v" + "sg\xde\x84:\xa0\xcb\xe8)\xeaX2\x86\x8d^\xa2" + "\x8d%C\xd8\x98F\xf6\x90C\xb5\x18*\xfbS42" + ";\x97\x18\xbcsv\xfd\xffI\x88\x8b<\xb2\xe3\x98t" + "\xac\xc4/+\xd0\x92?;\\\xba\xe4\x0a\xdb\xf6\xb0b" + "\xbd\x9c\xc1\xc2\xbc\xc9W\xe8\x10\xcat2\x8c\xf1\x9d\xbc" + "\x90\xfc\x153\xd4\xc1\x0eKG`\x93f\x87\xaa0h" + "n\xa2Ft\xe1x\xe4\x7f\x03\x00\x00\xff\xffYM," + "\\" func init() { schemas.Register(schema_db8274f9144abc7e, 0x84cb9536a2cf6d3c, 0x8891f360e47c30d3, 0x91f7a001ca145b9d, 0x9b87b390babc2ccf, 0x9e12cfad042ba4f1, 0xa29a916d4ebdd894, 0xa766b24d4fe5da35, 0xa78f37418c1077c8, 0xaa7386f356bd398a, 0xb14ce48f4e2abb0d, 0xb167b0bebe562cd0, 0xb70431c0dc014915, 0xb9d4ef45c2b5fc5b, 0xc082ef6e0d42ed1d, 0xc744e349009087aa, 0xc766a92976e389c4, 0xc793e50592935b4a, 0xcbd96442ae3bb01a, 0xd58a254e7a792b87, 0xdc3ed6801961e502, 0xe3e37d096a5b564e, 0xe4a6a1bc139211b4, 0xea20b390b257d1a5, 0xea58385c65416035, 0xf0a143f1c95a678e, 0xf143a395ed8b3133, 0xf2c122394f447e8e, 0xf2c68e2547ec3866, 0xf41a0f001ad49e46, 0xf7f49b3f779ae258, 0xf9c895683ed9ac4c, 0xfeac5c8f4899ef7c, 0xff8d9848747c956a) }