diff --git a/tunnelrpc/tunnelrpc.capnp b/tunnelrpc/tunnelrpc.capnp index cb707400..0afffc3f 100644 --- a/tunnelrpc/tunnelrpc.capnp +++ b/tunnelrpc/tunnelrpc.capnp @@ -56,204 +56,6 @@ struct RegistrationOptions { features @13 :List(Text); } -struct CapnpConnectParameters { - # certificate and token to prove ownership of a zone - originCert @0 :Data; - # UUID assigned to this cloudflared obtained from Hello - cloudflaredID @1 :Data; - # number of previous attempts to send Connect - numPreviousAttempts @2 :UInt8; - # user defined labels for this cloudflared - tags @3 :List(Tag); - # release version of cloudflared - cloudflaredVersion @4 :Text; - # which intent this cloudflared instance should get its behaviour from - intentLabel @5 :Text; -} - -struct ConnectResult { - result :union { - err @0 :ConnectError; - success @1 :ConnectSuccess; - } -} - -struct ConnectError { - cause @0 :Text; - # How long should this connection wait to retry in ns - retryAfter @1 :Int64; - shouldRetry @2 :Bool; -} - -struct ConnectSuccess { - # Information about the server this connection is established with - serverLocationName @0 :Text; - # How this cloudflared instance should be configured. This can be null if there isn't an intent for this origin yet - clientConfig @1 :ClientConfig; -} - -struct ClientConfig { - # Version of this configuration. This value is opaque, but is guaranteed - # to monotonically increase in value. Any configuration supplied to - # useConfiguration() with a smaller `version` should be ignored. - version @0 :UInt64; - # supervisorConfig is configuration for supervisor, the component that manages connection manager, - # autoupdater and metrics server - supervisorConfig @1 :SupervisorConfig; - # edgeConnectionConfig is configuration for connection manager, the componenet that manages connections with the edge - edgeConnectionConfig @2 :EdgeConnectionConfig; - # Configuration for cloudflared to run as a DNS-over-HTTPS proxy. - # cloudflared CLI option: `proxy-dns` - dohProxyConfigs @3 :List(DoHProxyConfig); - # Configuration for cloudflared to run as an HTTP reverse proxy. - reverseProxyConfigs @4 :List(ReverseProxyConfig); -} - -struct SupervisorConfig { - # Frequency (in ns) to check Equinox for updates. - # Zero means auto-update is disabled. - # cloudflared CLI option: `autoupdate-freq` - autoUpdateFrequency @0 :Int64; - # Frequency (in ns) to update connection-based metrics. - # cloudflared CLI option: `metrics-update-freq` - metricsUpdateFrequency @1 :Int64; - # Time (in ns) to continue serving requests after cloudflared receives its - # first SIGINT/SIGTERM. A second SIGINT/SIGTERM will force cloudflared to - # shutdown immediately. For example, this field can be used to gracefully - # transition traffic to another cloudflared instance. - # cloudflared CLI option: `grace-period` - gracePeriod @2 :Int64; -} - -struct EdgeConnectionConfig { - # cloudflared CLI option: `ha-connections` - numHAConnections @0 :UInt8; - # Interval (in ns) between heartbeats with the Cloudflare edge - # cloudflared CLI option: `heartbeat-interval` - heartbeatInterval @1 :Int64; - # Maximum wait time to connect with the edge. - timeout @2 :Int64; - # Number of unacked heartbeats for cloudflared to send before - # closing the connection to the edge. - # cloudflared CLI option: `heartbeat-count` - maxFailedHeartbeats @3 :UInt64; - # Absolute path of the file containing certificate and token to connect with the edge - userCredentialPath @4 :Text; -} - -struct ReverseProxyConfig { - tunnelHostname @0 :Text; - originConfig :union { - http @1 :HTTPOriginConfig; - websocket @2 :WebSocketOriginConfig; - helloWorld @3 :HelloWorldOriginConfig; - } - # Maximum number of retries for connection/protocol errors. - # cloudflared CLI option: `retries` - retries @4 :UInt64; - # maximum time (in ns) for cloudflared to wait to establish a connection - # to the origin. Zero means no timeout. - # cloudflared CLI option: `proxy-connect-timeout` - connectionTimeout @5 :Int64; - # (beta) Use cross-stream compression instead of HTTP compression. - # 0=off, 1=low, 2=medium, 3=high. - # For more context see the mapping here: https://github.com/cloudflare/cloudflared/blob/2019.3.2/h2mux/h2_dictionaries.go#L62 - # cloudflared CLI option: `compression-quality` - compressionQuality @6 :UInt64; -} - -struct WebSocketOriginConfig { - # URI of the origin service. - # cloudflared will start a websocket server that forwards data to this URI - # cloudflared CLI option: `url` - # cloudflared logic: https://github.com/cloudflare/cloudflared/blob/2019.3.2/cmd/cloudflared/tunnel/cmd.go#L304 - urlString @0 :Text; - # Whether cloudflared should verify TLS connections to the origin. - # negation of cloudflared CLI option: `no-tls-verify` - tlsVerify @1 :Bool; - # originCAPool specifies the root CA that cloudflared should use when - # verifying TLS connections to the origin. - # - if tlsVerify is false, originCAPool will be ignored. - # - if tlsVerify is true and originCAPool is empty, the system CA pool - # will be loaded if possible. - # - if tlsVerify is true and originCAPool is non-empty, cloudflared will - # treat it as the filepath to the root CA. - # cloudflared CLI option: `origin-ca-pool` - originCAPool @2 :Text; - # Hostname to use when verifying TLS connections to the origin. - # cloudflared CLI option: `origin-server-name` - originServerName @3 :Text; -} - -struct HTTPOriginConfig { - # HTTP(S) URL of the origin service. - # cloudflared CLI option: `url` - urlString @0 :Text; - # the TCP keep-alive period (in ns) for an active network connection. - # Zero means keep-alives are not enabled. - # cloudflared CLI option: `proxy-tcp-keepalive` - tcpKeepAlive @1 :Int64; - # whether cloudflared should use a "happy eyeballs"-compliant procedure - # to connect to origins that resolve to both IPv4 and IPv6 addresses - # negation of cloudflared CLI option: `proxy-no-happy-eyeballs` - dialDualStack @2 :Bool; - # maximum time (in ns) for cloudflared to wait for a TLS handshake - # with the origin. Zero means no timeout. - # cloudflared CLI option: `proxy-tls-timeout` - tlsHandshakeTimeout @3 :Int64; - # Whether cloudflared should verify TLS connections to the origin. - # negation of cloudflared CLI option: `no-tls-verify` - tlsVerify @4 :Bool; - # originCAPool specifies the root CA that cloudflared should use when - # verifying TLS connections to the origin. - # - if tlsVerify is false, originCAPool will be ignored. - # - if tlsVerify is true and originCAPool is empty, the system CA pool - # will be loaded if possible. - # - if tlsVerify is true and originCAPool is non-empty, cloudflared will - # treat it as the filepath to the root CA. - # cloudflared CLI option: `origin-ca-pool` - originCAPool @5 :Text; - # Hostname to use when verifying TLS connections to the origin. - # cloudflared CLI option: `origin-server-name` - originServerName @6 :Text; - # maximum number of idle (keep-alive) connections for cloudflared to - # keep open with the origin. Zero means no limit. - # cloudflared CLI option: `proxy-keepalive-connections` - maxIdleConnections @7 :UInt64; - # maximum time (in ns) for an idle (keep-alive) connection to remain - # idle before closing itself. Zero means no timeout. - # cloudflared CLI option: `proxy-keepalive-timeout` - idleConnectionTimeout @8 :Int64; - # maximum amount of time a dial will wait for a connect to complete. - proxyConnectionTimeout @9 :Int64; - # The amount of time to wait for origin's first response headers after fully - # writing the request headers if the request has an "Expect: 100-continue" header. - # Zero means no timeout and causes the body to be sent immediately, without - # waiting for the server to approve. - expectContinueTimeout @10 :Int64; - # Whether cloudflared should allow chunked transfer encoding to the - # origin. (This should be disabled for WSGI origins, for example.) - # negation of cloudflared CLI option: `no-chunked-encoding` - chunkedEncoding @11 :Bool; -} - -# configuration for cloudflared to provide a DNS over HTTPS proxy server -struct DoHProxyConfig { - # The hostname for the DoH proxy server to listen on. - # cloudflared CLI option: `proxy-dns-address` - listenHost @0 :Text; - # The port for the DoH proxy server to listen on. - # cloudflared CLI option: `proxy-dns-port` - listenPort @1 :UInt16; - # Upstream endpoint URLs for the DoH proxy server. - # cloudflared CLI option: `proxy-dns-upstream` - upstreams @2 :List(Text); -} - -struct HelloWorldOriginConfig { - # nothing to configure -} - struct Tag { name @0 :Text; value @1 :Text; @@ -269,21 +71,6 @@ struct ServerInfo { locationName @0 :Text; } -struct UseConfigurationResult { - success @0 :Bool; - failedConfigs @1 :List(FailedConfig); -} - -struct FailedConfig { - config :union { - supervisor @0 :SupervisorConfig; - edgeConnection @1 :EdgeConnectionConfig; - doh @2 :DoHProxyConfig; - reverseProxy @3 :ReverseProxyConfig; - } - reason @4 :Text; -} - struct AuthenticateResponse { permanentErr @0 :Text; retryableErr @1 :Text; @@ -296,11 +83,7 @@ interface TunnelServer { getServerInfo @1 () -> (result :ServerInfo); unregisterTunnel @2 (gracePeriodNanoSec :Int64) -> (); # obsoleteDeclarativeTunnelConnect RPC deprecated in TUN-3019 - obsoleteDeclarativeTunnelConnect @3 (parameters :CapnpConnectParameters) -> (result :ConnectResult); + obsoleteDeclarativeTunnelConnect @3 () -> (); authenticate @4 (originCert :Data, hostname :Text, options :RegistrationOptions) -> (result :AuthenticateResponse); reconnectTunnel @5 (jwt :Data, eventDigest :Data, connDigest :Data, hostname :Text, options :RegistrationOptions) -> (result :TunnelRegistration); } - -interface ClientService { - useConfiguration @0 (clientServiceConfig :ClientConfig) -> (result :UseConfigurationResult); -} diff --git a/tunnelrpc/tunnelrpc.capnp.go b/tunnelrpc/tunnelrpc.capnp.go index 5b824580..6bc9c889 100644 --- a/tunnelrpc/tunnelrpc.capnp.go +++ b/tunnelrpc/tunnelrpc.capnp.go @@ -4,7 +4,6 @@ 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" @@ -567,1566 +566,6 @@ func (p RegistrationOptions_Promise) Struct() (RegistrationOptions, error) { 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 } -type ConnectResult_result ConnectResult -type ConnectResult_result_Which uint16 - -const ( - ConnectResult_result_Which_err ConnectResult_result_Which = 0 - ConnectResult_result_Which_success ConnectResult_result_Which = 1 -) - -func (w ConnectResult_result_Which) String() string { - const s = "errsuccess" - switch w { - case ConnectResult_result_Which_err: - return s[0:3] - case ConnectResult_result_Which_success: - return s[3:10] - - } - return "ConnectResult_result_Which(" + strconv.FormatUint(uint64(w), 10) + ")" -} - -// 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: 8, PointerCount: 1}) - return ConnectResult{st}, err -} - -func NewRootConnectResult(s *capnp.Segment) (ConnectResult, error) { - st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}) - 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) Result() ConnectResult_result { return ConnectResult_result(s) } - -func (s ConnectResult_result) Which() ConnectResult_result_Which { - return ConnectResult_result_Which(s.Struct.Uint16(0)) -} -func (s ConnectResult_result) Err() (ConnectError, error) { - if s.Struct.Uint16(0) != 0 { - panic("Which() != err") - } - p, err := s.Struct.Ptr(0) - return ConnectError{Struct: p.Struct()}, err -} - -func (s ConnectResult_result) HasErr() bool { - if s.Struct.Uint16(0) != 0 { - return false - } - p, err := s.Struct.Ptr(0) - return p.IsValid() || err != nil -} - -func (s ConnectResult_result) SetErr(v ConnectError) error { - s.Struct.SetUint16(0, 0) - 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_result) NewErr() (ConnectError, error) { - s.Struct.SetUint16(0, 0) - 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_result) Success() (ConnectSuccess, error) { - if s.Struct.Uint16(0) != 1 { - panic("Which() != success") - } - p, err := s.Struct.Ptr(0) - return ConnectSuccess{Struct: p.Struct()}, err -} - -func (s ConnectResult_result) HasSuccess() bool { - if s.Struct.Uint16(0) != 1 { - return false - } - p, err := s.Struct.Ptr(0) - return p.IsValid() || err != nil -} - -func (s ConnectResult_result) SetSuccess(v ConnectSuccess) error { - s.Struct.SetUint16(0, 1) - return s.Struct.SetPtr(0, v.Struct.ToPtr()) -} - -// NewSuccess sets the success field to a newly -// allocated ConnectSuccess struct, preferring placement in s's segment. -func (s ConnectResult_result) NewSuccess() (ConnectSuccess, error) { - s.Struct.SetUint16(0, 1) - ss, err := NewConnectSuccess(s.Struct.Segment()) - if err != nil { - return ConnectSuccess{}, err - } - err = s.Struct.SetPtr(0, 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: 8, PointerCount: 1}, 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) Result() ConnectResult_result_Promise { - return ConnectResult_result_Promise{p.Pipeline} -} - -// ConnectResult_result_Promise is a wrapper for a ConnectResult_result promised by a client call. -type ConnectResult_result_Promise struct{ *capnp.Pipeline } - -func (p ConnectResult_result_Promise) Struct() (ConnectResult_result, error) { - s, err := p.Pipeline.Struct() - return ConnectResult_result{s}, err -} - -func (p ConnectResult_result_Promise) Err() ConnectError_Promise { - return ConnectError_Promise{Pipeline: p.Pipeline.GetPipeline(0)} -} - -func (p ConnectResult_result_Promise) Success() ConnectSuccess_Promise { - return ConnectSuccess_Promise{Pipeline: p.Pipeline.GetPipeline(0)} -} - -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 ConnectSuccess struct{ capnp.Struct } - -// ConnectSuccess_TypeID is the unique identifier for the type ConnectSuccess. -const ConnectSuccess_TypeID = 0x8407e070e0d52605 - -func NewConnectSuccess(s *capnp.Segment) (ConnectSuccess, error) { - st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}) - return ConnectSuccess{st}, err -} - -func NewRootConnectSuccess(s *capnp.Segment) (ConnectSuccess, error) { - st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}) - return ConnectSuccess{st}, err -} - -func ReadRootConnectSuccess(msg *capnp.Message) (ConnectSuccess, error) { - root, err := msg.RootPtr() - return ConnectSuccess{root.Struct()}, err -} - -func (s ConnectSuccess) String() string { - str, _ := text.Marshal(0x8407e070e0d52605, s.Struct) - return str -} - -func (s ConnectSuccess) ServerLocationName() (string, error) { - p, err := s.Struct.Ptr(0) - return p.Text(), err -} - -func (s ConnectSuccess) HasServerLocationName() bool { - p, err := s.Struct.Ptr(0) - return p.IsValid() || err != nil -} - -func (s ConnectSuccess) ServerLocationNameBytes() ([]byte, error) { - p, err := s.Struct.Ptr(0) - return p.TextBytes(), err -} - -func (s ConnectSuccess) SetServerLocationName(v string) error { - return s.Struct.SetText(0, v) -} - -func (s ConnectSuccess) ClientConfig() (ClientConfig, error) { - p, err := s.Struct.Ptr(1) - return ClientConfig{Struct: p.Struct()}, err -} - -func (s ConnectSuccess) HasClientConfig() bool { - p, err := s.Struct.Ptr(1) - return p.IsValid() || err != nil -} - -func (s ConnectSuccess) SetClientConfig(v ClientConfig) error { - return s.Struct.SetPtr(1, v.Struct.ToPtr()) -} - -// NewClientConfig sets the clientConfig field to a newly -// allocated ClientConfig struct, preferring placement in s's segment. -func (s ConnectSuccess) NewClientConfig() (ClientConfig, error) { - ss, err := NewClientConfig(s.Struct.Segment()) - if err != nil { - return ClientConfig{}, err - } - err = s.Struct.SetPtr(1, ss.Struct.ToPtr()) - return ss, err -} - -// ConnectSuccess_List is a list of ConnectSuccess. -type ConnectSuccess_List struct{ capnp.List } - -// NewConnectSuccess creates a new list of ConnectSuccess. -func NewConnectSuccess_List(s *capnp.Segment, sz int32) (ConnectSuccess_List, error) { - l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz) - return ConnectSuccess_List{l}, err -} - -func (s ConnectSuccess_List) At(i int) ConnectSuccess { return ConnectSuccess{s.List.Struct(i)} } - -func (s ConnectSuccess_List) Set(i int, v ConnectSuccess) error { return s.List.SetStruct(i, v.Struct) } - -func (s ConnectSuccess_List) String() string { - str, _ := text.MarshalList(0x8407e070e0d52605, s.List) - return str -} - -// ConnectSuccess_Promise is a wrapper for a ConnectSuccess promised by a client call. -type ConnectSuccess_Promise struct{ *capnp.Pipeline } - -func (p ConnectSuccess_Promise) Struct() (ConnectSuccess, error) { - s, err := p.Pipeline.Struct() - return ConnectSuccess{s}, err -} - -func (p ConnectSuccess_Promise) ClientConfig() ClientConfig_Promise { - return ClientConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)} -} - -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. @@ -2346,354 +785,6 @@ func (p ServerInfo_Promise) Struct() (ServerInfo, error) { 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 AuthenticateResponse struct{ capnp.Struct } // AuthenticateResponse_TypeID is the unique identifier for the type AuthenticateResponse. @@ -2889,7 +980,7 @@ func (c TunnelServer) ObsoleteDeclarativeTunnelConnect(ctx context.Context, para Options: capnp.NewCallOptions(opts), } if params != nil { - call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1} + call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0} call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_obsoleteDeclarativeTunnelConnect_Params{Struct: s}) } @@ -3014,7 +1105,7 @@ func TunnelServer_Methods(methods []server.Method, s TunnelServer_Server) []serv call := TunnelServer_obsoleteDeclarativeTunnelConnect{c, opts, TunnelServer_obsoleteDeclarativeTunnelConnect_Params{Struct: p}, TunnelServer_obsoleteDeclarativeTunnelConnect_Results{Struct: r}} return s.ObsoleteDeclarativeTunnelConnect(call) }, - ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1}, + ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0}, }) methods = append(methods, server.Method{ @@ -3560,12 +1651,12 @@ type TunnelServer_obsoleteDeclarativeTunnelConnect_Params struct{ capnp.Struct } const TunnelServer_obsoleteDeclarativeTunnelConnect_Params_TypeID = 0xa766b24d4fe5da35 func NewTunnelServer_obsoleteDeclarativeTunnelConnect_Params(s *capnp.Segment) (TunnelServer_obsoleteDeclarativeTunnelConnect_Params, error) { - st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}) return TunnelServer_obsoleteDeclarativeTunnelConnect_Params{st}, err } func NewRootTunnelServer_obsoleteDeclarativeTunnelConnect_Params(s *capnp.Segment) (TunnelServer_obsoleteDeclarativeTunnelConnect_Params, error) { - st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}) return TunnelServer_obsoleteDeclarativeTunnelConnect_Params{st}, err } @@ -3579,37 +1670,12 @@ func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Params) String() string { return str } -func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Params) Parameters() (CapnpConnectParameters, error) { - p, err := s.Struct.Ptr(0) - return CapnpConnectParameters{Struct: p.Struct()}, err -} - -func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Params) HasParameters() bool { - p, err := s.Struct.Ptr(0) - return p.IsValid() || err != nil -} - -func (s TunnelServer_obsoleteDeclarativeTunnelConnect_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_obsoleteDeclarativeTunnelConnect_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_obsoleteDeclarativeTunnelConnect_Params_List is a list of TunnelServer_obsoleteDeclarativeTunnelConnect_Params. type TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List struct{ capnp.List } // NewTunnelServer_obsoleteDeclarativeTunnelConnect_Params creates a new list of TunnelServer_obsoleteDeclarativeTunnelConnect_Params. func NewTunnelServer_obsoleteDeclarativeTunnelConnect_Params_List(s *capnp.Segment, sz int32) (TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List, error) { - l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz) return TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List{l}, err } @@ -3634,22 +1700,18 @@ func (p TunnelServer_obsoleteDeclarativeTunnelConnect_Params_Promise) Struct() ( return TunnelServer_obsoleteDeclarativeTunnelConnect_Params{s}, err } -func (p TunnelServer_obsoleteDeclarativeTunnelConnect_Params_Promise) Parameters() CapnpConnectParameters_Promise { - return CapnpConnectParameters_Promise{Pipeline: p.Pipeline.GetPipeline(0)} -} - type TunnelServer_obsoleteDeclarativeTunnelConnect_Results struct{ capnp.Struct } // TunnelServer_obsoleteDeclarativeTunnelConnect_Results_TypeID is the unique identifier for the type TunnelServer_obsoleteDeclarativeTunnelConnect_Results. const TunnelServer_obsoleteDeclarativeTunnelConnect_Results_TypeID = 0xfeac5c8f4899ef7c func NewTunnelServer_obsoleteDeclarativeTunnelConnect_Results(s *capnp.Segment) (TunnelServer_obsoleteDeclarativeTunnelConnect_Results, error) { - st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}) return TunnelServer_obsoleteDeclarativeTunnelConnect_Results{st}, err } func NewRootTunnelServer_obsoleteDeclarativeTunnelConnect_Results(s *capnp.Segment) (TunnelServer_obsoleteDeclarativeTunnelConnect_Results, error) { - st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}) + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}) return TunnelServer_obsoleteDeclarativeTunnelConnect_Results{st}, err } @@ -3663,37 +1725,12 @@ func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Results) String() string { return str } -func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Results) Result() (ConnectResult, error) { - p, err := s.Struct.Ptr(0) - return ConnectResult{Struct: p.Struct()}, err -} - -func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Results) HasResult() bool { - p, err := s.Struct.Ptr(0) - return p.IsValid() || err != nil -} - -func (s TunnelServer_obsoleteDeclarativeTunnelConnect_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_obsoleteDeclarativeTunnelConnect_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_obsoleteDeclarativeTunnelConnect_Results_List is a list of TunnelServer_obsoleteDeclarativeTunnelConnect_Results. type TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List struct{ capnp.List } // NewTunnelServer_obsoleteDeclarativeTunnelConnect_Results creates a new list of TunnelServer_obsoleteDeclarativeTunnelConnect_Results. func NewTunnelServer_obsoleteDeclarativeTunnelConnect_Results_List(s *capnp.Segment, sz int32) (TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List, error) { - l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz) + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz) return TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List{l}, err } @@ -3718,10 +1755,6 @@ func (p TunnelServer_obsoleteDeclarativeTunnelConnect_Results_Promise) Struct() return TunnelServer_obsoleteDeclarativeTunnelConnect_Results{s}, err } -func (p TunnelServer_obsoleteDeclarativeTunnelConnect_Results_Promise) Result() ConnectResult_Promise { - return ConnectResult_Promise{Pipeline: p.Pipeline.GetPipeline(0)} -} - type TunnelServer_authenticate_Params struct{ capnp.Struct } // TunnelServer_authenticate_Params_TypeID is the unique identifier for the type TunnelServer_authenticate_Params. @@ -4152,533 +2185,152 @@ func (p TunnelServer_reconnectTunnel_Results_Promise) Result() TunnelRegistratio return TunnelRegistration_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\xccZ{\x90\x15ev?\xa7\xfb\xde\xe9\x19`" + - "\xb8\xb7\xed\xb1\x18X`\x041+\xac\x10u\xd6\xc4\x9d" + - "$;O\xd8\x19\x16az\xee\x0c\xba#\xa6\xec\xb9\xf7" + - "\x9b\x99\x86\xbe\xdd\x97~\x00CpA\x0a\xa2L`\x05" + - "\x17R\xe0\xe2\x16\xe0\x12\x1fq\xb3\xe2be5jI" + - "\xb2\x1b$\xabQ6\x98\x92\x8dVT\xb0Rk\xad\xe5" + - "\xa2\xa6,Sj\xa7N\xbf\xe7\xce0\x03k\xfe\xc8?" + - ":u\xee\xe9\xefq\x1e\xbf\xf3;\xe7\xe3\xfa\x9d\x93\x9a" + - "\xb8\x1b\xd2'\xab\x01\xe4C\xe9\x0a\x97-\xf8\xd5\xc6C" + - "\xd7\xfc\xd3V\x90g \xba\xdf}vi\xcd\xa7\xf6\xd6" + - "\xff\x804/\x00\xd4\x9f\xaa\xd8\x88\xd2\x9b\x15\x02\x80t" + - "\xb6\xe2\xbf\x00\xdd\xf4\x1f\xbc\xf6V\xe9-a\x1b\x883" + - "\x92\xca\x1c)?',E\xe9\xb4@\xca/\x0b\xeb\x01" + - "\xdd?-\xber\xe4\x8f\xf6\xfd\x92\x94\xb9X\x19\xb0\xfe" + - "\xa6\xca\x8d(uT\x92\xe6\xe2\xca\x15\x80\xeeG{k" + - "\xff\xf6\xf0\xbf\xbe\xb8\x1d\xc4\xaf\"\x04{\xdfQ\xf9k" + - "\x04\x94\xd6V\xfe\x04\xd0\xfd\xb7\xeb7\x9d\xbf\xf3\xa3=" + - "\xf7\x8e\xdc7Ezb\xd50J\xf3\xab\x04\xe0\xdd\x07" + - "o\xaf\xf9\x17<\xf4\xc9\x1e\x10\xaf\xa5e\x90~NW" + - "M\xe2\x00\xa5YU\x8d\x80\xee+\xd7=\xfb\xcc\xee\x9f" + - "\xde\xf3\x03\x90\xbf\x8a\x08\xfe\xf7\x7fV\xf5?\xb4\x8f\xec" + - ")\\\xf8\xd1\xd7R?~\xe5\x8a\x1fz\x0a\xee\xd1\xd3" + - "\xb7>\xb9\xfb\xa7W\xbd\x07=\x9c\x80)\x80\xfa\xa1*" + - "\x93t\xb7W\x91-\xf6\xbe\xfe\xdc\xf2\xe2\x9e\x07\x8e\xf8" + - "\x87\xf6\xd6b\x938\x0eR\xee\xb6\x8eO\x8a=\x0f\xe5" + - "\x1e\x0a\xae\x93\xa6\x9f\xbe3\xe9C\x04\xac/N\xaaC" + - "@\xf7\xa6_\xbf\xbb\xe2\x96'\xfb\x1f\x0e4\xbc\x93\xee" + - "\x98\xbc\x91Nzt2\x1d\xe4\xc5\xf5\xd9\x9d\xcd\x7f|" + - "\xdf\xc3\xe5n\xf1\xd6:5y\x18\xa5\xb7'\xd3\x9fo" + - "N\xbe\x95\xd6\x1b\xfe\xc6s+?\xfaK\xeb1\x90\x17" + - "b\xca\xfd\xf9\x8es\xeb\xe6?\xda\x7f\xd2;7\x0fP" + - "\xdfS\xfd+:\xb7ZM\xb6\xac\xfe\x87\x05\xcb\xef;" + - "\xbf\xec\x18-\x9d\xf0\x8b\x7f\x88\xaa\xa9\x0d(M\x9fJ" + - "\xae\xb9r*i\xbfz\xdd\xca\xe7\x9f\x7fb\xe0X\xf9" + - "A<\x97?5u)J\xa7<\xed_x\xdaWv" + - "\xe0\x1b/\xdc\x90\xfa\xfb\xa4#\x872\xef\xd1\xe6\xbb2" + - "\xa4p\xfbgO\xfd\xe3\xe2\x0f\xce<\x9dt\xd1\xc2," + - "G\x17o\xce\xd2\xc5{\x87\xb1\xf8FC\xd3\xf3 _" + - "\x8b\xe8\xae\xde\xb7\xc9n\xdf\xbf\xcb\x85\x1e\x14\x90\x03\xa8" + - "W\xb3\x1bi1'K\x016\xeb\xfd\x96j\xfd\x83\xad" + - "/\x94E\xa3\xb7\xeb\xe9\xecR\x94\xde\xcd\xd2\xd1\xde\xce" + - "\xfe\x04\xf0\x93\xc7\xee\xd9\xddq\xae\xed\xa4<\x03S\xe5" + - "\x97\xbeK\xdc\x88\xd2\x1e\x91\xfe\xdc%z\xfe\x89,X" + - "\xa6\xee\x07\xfa\x15\xabQ:}\x05\xfd\xf9\xf2\x15\x9e\xfa" + - "\xd2\xdb\xbf\x7f\x7f\xfa\xdd\xef\x9f,7)\x85x\xfdY" + - "\xc9D\xe9}\x89\xfe\xfc\x8d4\x8d\x07tg<\xf1'" + - "\x7f\xd7R8\xfb\xcb1\xb2HR\xa7}(9\xd3\xe8" + - "\xaf\xb5\xd3\xe8\x8e\xe7\x16\x1e\xfb\x8b\xdf\xec:}&\x19" + - ")/O\xf3B\xf6\xedid\xb0{\xbe6\xb4q\xf9" + - "5\xc3\xaf\x95;\xc8\xd3\xc4\xdaa\x94\xa6\xd7z\xee\xac" + - "\xa5\xe5\xb8w\x95\xe9[\xfe\xfd\x9bo$\x82v{\xed" + - ";\x08)w\xf9\xca\xdbWW\xddu\xee\\r\xa3\xa1" + - "Z\xdfu\xb5\xb4\xd1q\xf1~\xe9\xd9\xc3\x7fs\x9e6" + - "\x12\xca\xcd\xfd\xe3\xda^\x94N\xd4z\xe6\xa9}\x98\x83" + - "D\xf2\x8c\x158O\x7f\xa5\x01\xa5S_\xf1\x02\xe7+" + - "t\xae\x9b\xeelf\xabn\xbe\xed=\x10g\xf0#\xb0" + - "\"=\xb3\x01\xa5+gz\x99>\xf3\x1e\x94\xe6\xcf\x12" + - "\x00\xdc\xef\x0d\xf4\x9e\xba\xd0z\xf8w\xe5\x8b\xfb\x880" + - "\xab\x01\xa59\xa4W?k\x96\xe7\x9f\xfa\x1b\xfe\xea\xfd" + - "}\x0f\xb5^\x18\xb5\xba:\xbb\x05\xa5\xa1\xd9t\x0eg" + - "\xf6\xb7\xa4\xa3\xb3\xbd\xc5\xbf\xdb\xb6\xe2\x1bsO|\x98" + - "\xb4\xc4\xae\xd9\x94\xbe\xd2\xe1\xd9d\x89\xfe\x9b\x7f\xfb\xad" + - "k\xbe\xf7\xcf\x1f\x96\xf9\xcfS<1{\x01J\xa7\xbd" + - "\x15_&\xe5\x0f\x96\xfc\xf0\xcc\x8c\xcc\x8c\x8f\xcb\x0eJ" + - "\x98Z\x7fa\xf6j\x94\xd2u\x9e\xa3\xeaN\xd2Ao" + - "{\xe7\x81\xf5\x8d?\xf8\xf8\x13\xba\x17_\x06t\xff}" + - "U/JUsh\xe5\xf4\x1c\xca\xa5e\x8f\x9f\xfd\xe6" + - "\xe0\xbe\x17?\x1d\x13\xba\x8f\xcd\xd9\x8a\xd2/<\xed\x13" + - "s\x08\xae\xfeZ8xn\xcb\x7f\xfe\xf9g\xc9[=" + - ":\xf7\x1d\xba\xd5ss\xe9V\x9b>8\xd0~\xdf\xaa" + - "\xc7\xbfH*\xbc9w+\xa5\xe6\xa7\x9eB\x94\x8cc" + - "E\xda\xf4\xab[P\x9a\x7f5\xedw\xcd\xd5\xa4m;" + - "\xba\xce4\xb3\x94\xca\xffa\xf8g~Q^)\xe9\xa5" + - "\x86f\xc7\x1ed\xba\xad\xe6\x15\x9bu\xb1F\xabd\xe8" + - "\x16\xebD\x94\xb3|\x0a \x85\x00\xa2\xb2\x1a@\xbe\x93" + - "GY\xe3PD\xac!\xb8\x16U\x12\x0e\xf2(\xdb\x1c" + - "\x8a\x1cWC\x88 \xae\x9d\x0b k<\xca\x1b8D" + - "\xbe\x86\xf0Nt\xee\x07\x907\xf0(o\xe3\xd0-1" + - "\xb3\xa8\xe8L\x87\x8c\xbd\xd84q\x0ap8\x05\xd05" + - "\x99m\x0e)}\x1adXB,\xac^oc5p" + - "X\x0d\xe8\x0e\x1a\x8ei\xf5\xe86\xaaZ\x17\xeb7\x99" + - "\x85\x83X\x01\x1cV\x8c\x7f\xbdVC\xd7Y\xde\xce9" + - "\xf9<\xb3,\x00\xbaYet\xb3\xf9\x0f\x00\xc8\xd7\xf1" + - "(\xdf\x9c\xb8\xd9Mt\xb3\xaf\xf3(7q\xe8Z\xcc" + - "\\\xc7\xcce\x06\xe6\x15[5\xf4\xe5\x0a_d\xd1\xb1" + - "\xf3\x9a\xcat\xbb\xd5\x80\x8c\xde\xaf\x0e`6N\x05@" + - "\xcc\x8e\x7f\xb0\xc5\x1bT\xcbV\xf5\x81nO\xde\xd8i" + - "hj~\x88N7\xc5\xb3\xe4\xac\x06ZC\xbc\xb2\x17" + - "\x009Ql\x01hT\x07t\xc3dnA\xb5\xf2t" + - ")\xe0\xf3\xf6\xe6>ES\xf4<\x8b6\xaa\x18\xbd\x91" + - "\xbfA\xce\xbb\xc7\"%\xe1\xedy\x9d\x8a\xa9\xf0EK" + - "\x9e\x12\xd9cq/\x80\xdc\xc6\xa3\xdc\x99\xb0\xc7-K" + - "\x01\xe4e<\xca\xb7%<\xdd\xd3\x02 w\xf2(\xaf" + - "\xe2\xd05Lu@\xd5[\x19\xf0f\xd2a\x96\xad+" + - "E\x06\x00\xa1\xc16\x1b%2\xa2\x85\xd9\x18\xa5\xcb," + - "\x95\x1e}\x81v\xa6i\xc6\xad\x86\xa9\x15V\xf8\xfb\x18" + - "dm\xcf\x95\xd1g\xc2\x18\x9e\xf7\x9cC\xf7V\xf3l" + - "\x91c1\xff;\xc7\xf4\x1c9\xaf\x8bY\x8ef[\x00" + - "r*\xba~u\x03\x80\\\xc9\xa3\\\xc3a\xa3\xe9)" + - "`6\x06\xf5\xb2\xa3NdkG7\xd9\x80j\xd9\xcc" + - "\xf4\xc5\xf3\x1a\xc9\xe0E+\xb9!\xc5_\x96Gy&" + - "\x87\xee\x80\xa9\xe4Y'3Q5\x0a\xcb\x15\xdd\xc8\xf1" + - ",\x8fi\xe00=~$-QT\x8d\x15\xfc\xdb-" + - "\xca\xd7y\xff\xa7\xec\x9d\xe2\xba~\xfa\xf6\xc6\xe9[\x8d" + - "_\xb8A\xfen\x8c\xf3\xb7\x9a\xfb\xdc\x1d\x9d\xc0\xd5\xfc" + - "gn\x90\xc2\x94\x116\x8f\xf2\x16\xca\x08\xa7D6\xb5" + - "\x807L\xcc\xc6(\x19X\x87\x15\x06\xc8\xd2:4\xb2" + - "<\x19\x1a\xb3a\xb5\xf7\x15\x84\x821\x88\xd9\x98\xca\x04" + - "\x9f\x99l\x1d3-\xd6\x09\x19\xd3\xd80\x84\xd9\xb8\xea" + - "\x97Y}\xea\xe5Z=tt\xf4\xd5\xf8\xdf\x9b,\xef" + - "CF\xf0yg\x9d\xef\xb4\x9a\xc8iw\xcd\x8d\x01-" + - "J\x92\xbb\xfb\x00\xe4-<\xca;\x13I\xb2\x83,\x7f" + - "/\x8f\xf2^\x0eE>\xc0\xc3=\x94N\xbby\x94\x0f" + - "r(\xa6R5Df\xc5\x03\x94N{y\x94\x0fq" + - "#a\x8f\xadc\xba\xdd\xa6\x0e\x80\xc0\xacXJGl" + - "S\x07\x18\xf0\xd6\x97M\xb8\xca\x09\xeca\xf4Y\x86\xc6" + - "l\xd6\xc6\xf2\x9aB\xb9\xb3\x8e\xf9\xbf\x07\xc8:VT" + - "\xd3\xb5\xa7\xf0(\xd7\x12\xe2\xd3\xaf\xcc&l\xa0cD" + - "\\z\xe2\xbco\xa5\xff\x06\xbbt\x06\xab\x98\x01\x84\xd7" + - "F\x9b\x1d\xa0\xcd\xf6\xf3(\xff(\xe1\x8d\xc3&uT" + - "<\xca\x8fs\x88\x813\x1e=\x02 ?\xce\xa3\xfc3" + - "r\x06\xe7;\xe3\xa9\x05\x00\xf2\x13<\xca/\x913x" + - "\xdf\x19\xa7(+_\xe2Q~\x9dC1\x9d\xaa\xc14" + - "\x80\xf8\x1a9\xf8\x0c\x8f\xf2[\x17\x03\xbc\xbcf8\x85" + - "~M\x81:\x93\x15:\xda\"\xb9\xee\x14;M\xb6N" + - "E\xc3\xb1\x9am\x9b\x15\x85\x92m\x85\xb5+c+\x03" + - "\x16N\x05\xec\xe4\x11\xb31\x1b\x05$a\xb4&\x9a\xac" + - "\xb0\x92\x99\x96\xca\x1bzT~T\xddf\xba\xbdL\x01" + - "\xa1\x8fi\x91t\x1cx\xea\x0a\x92\x8cR,\xc0\x0b#" + - "\x86T\x1c\xa0J0\xd3u\x03#.&\xdb4\xf1(" + - "/\xe3p\x16~Ab\xb2cG\x17\x80\xdc\xce\xa3\xdc" + - "\xcd\xe1,\xees\x12\x93%\xe5\xde\xb8 d\x06m\xbb" + - "\x84\xd9\x98\xa5\x06\xce^\xcf\xfa,#\xbf\x86\x01\x12\xae" + - "F\x94)\xf8u0\xc0y\xe0\xb5\x02f\xe36\xb3," + - "R\xf8\x8b\x15\xf9F\xa2\x14\x86\xe9\xd5\xd0\xb8\xa2\xdd\x18" + - "_\"\x8c\x8e\x8e\xde\xf8\x06\"\xd7\xe4_K\xee\x8b\xcf" + - "_\x97W\x1c\x8b\x8dd'\xcd\xfd6\xf0\xcc\x8c\x00\xd9" + - "\x1a4\x1c\xad\xd0\xc5@\xb0\xcd!D\xe0\x10\xc7\x87\xe9" + - "6\xa3=ax?\x8c\xc7\xae\xbcQ\xe1\xedM\x16\xde" + - "\xc0\xfc=d\xfen\x1e\xe5\x12\x87\xaeF@\xa7\xb7\x1b" + - "\x1e\x0e\x84\xc7\xf5\x85\x9d\x86\x17\x9c\x02p(\x00\xbaN" + - "\xc9\xb2M\xa6\x14\x01\xa3h#\xfd\xa9\x97Q\xcf\xcap" + - "\xb5S\xc9xy\xff\xff\x89=\\>\x0d\xf0\xc1k\x04" + - "\x098\x92\xa8\xc9\xf9\xe0k\xf4>o5t\xe1\xb2\x89" + - "^\x80`~\x19Z\x14\xd0\x0a\xe2\xa0a}\x9eO\xf5" + - "d\x1e\x8f\xf2\xf5\xc9\xfa\xbc\x90Lt-\x8f\xf2\xd79" + - "\x14\x98I\xa56\x1a\x16\xf8\x9bn\xb6|R\x8b\xd9x" + - "\x144\xf1q\x12|_5\xf4Qa87N\x97\xc8" + - "\x85\x1d7&\xfc\x1a\xba\xf0\x96\xbe\xd8\xaf\xc2\x1a6\x14" + - "z\xa9\x8e\x15\x155F\xa3\xc0\xb9\xcd |;\xd6\x19" + - "\x97\x17\x07\xfc\xc1g\x0f\x8d\xbe\xb7\xe8\x90\x89\x02<\x9c" + - "\xa8\xb5\xe1!wP\x9b\xb1\x93Gy\x7f\xe2\x90\xfbZ" + - "\x12\xb56,\xc0\x07\xc8\xc1\x07y\x94\x1f\xe1\x10\x83\xfa" + - "{\x94 \xff\x11\x1e\xe5\xe3\x9c\x07\xd8\xed\xcd\xad\x86\x8e" + - "\xc1!,\x80\xa8\xd5\x18d\x8ai\xf71\x05\xed\x0e\xdd" + - "f\xe6:\x05\xb5\x10\x126\xdbj\x91\x19\x8e\x1dAD" + - "Q\xd9\xe0q3,\xb4\xfb_\x09\x8ama\x15pX" + - "E\x19i1\xb3\xd5d\x05$o(Z\xa7\xc2\xdb\x83" + - "\x97b\xa0\x91 \x9e\x19\xc3<\xc4\xec6\xf1(\xdfK" + - "P\x82\x89\x81\x94\xb8}5p\x1e\x92\xd0\x9d\xd7\xb6\xc4" + - "\\\xcf+\x88\xe9\xb2n\xcd+\x88\x15Dn\xc8:\xdb" + - "x\x94ws\xe1\xd1\xda\x0dh\xf43\xb4\xdc\xd5A7" + - "\xb4\x99PSe\xf1}\x03Z\xa5\xa2\xa1w{\x86\xc2" + - "\xd8Ry\xa3X2)\x94UC\x97\x1dESy{" + - "(\xfap\\[\x10$\xf9\xa9\xbc\xa2T\xe79\x8b\x8c" + - "qsh\x0ci\x08\x97\x02\xe46 \x8f\xb9m\x18\x87" + - "\x8bt7\xb6\x00\xe46\x91\xfc^\x8c#F\xda\x8e3" + - "\x00r[H\xbe\x13\xa3&V\xda\x81\x8f\x01\xe4v\x92" + - "x?\xc6TA\xda\xe7-\xbf\x97\xe4\x870f\x0b\xd2" + - "\x83\xb8\x00 \xb7\x9f\xe4\xc7I^\xc1y\x96\x94\x8e\xe1" + - "j\x80\xdc\x13$\x7f\x96\xe4B\xba\x86:v\xe9i4" + - "\x01r?#\xf9\xcfI^Y[\x83\x95\x00\xd2\x09O" + - "\xfe\x02\xc9_\"y\xd5\xf4\x1a\xac\x02\x90N\xe1V\x80" + - "\xdc\x8b$?C\xf2IX\x83\x93\x00\xa4\xd3\xf8\x00@" + - "\xee\x0c\xc9\xdf\"\xf9\xe4\x8a\x1a\x9c\x0c \xbd\xe9\x9d\xe7" + - "u\x92\x9f'\xf9\x94T\x0dN\x01\x90\xde\xc6#\x00\xb9" + - "\xf3$\xff\x1d\xc9\xab\x85\x1a\xac\x06\x90\xde\xf7\xee\xf5[" + - "\x92Wr\x11\x0ev\x14\x92pLa\xa8\xc6t\x847" + - "\xac(\x14X\xd0\xdc\xa2_+:\x8d\x0cu\xb7\x98\x89" + - "\xc7\xd0\x80\x98\x01tK\x86\xa1-\x1f\x09\xf3\x131\xa2" + - " \x8c c\xe8\x1d\x85(/\xfd\xe0[f@]^" + - "\xd1:J1G\xb2\x9a\x1d\xdbpJPWPlV" + - "\x88\x0a\xb5\xe9\xe8KL\xa3\xd8\x8d\xcc,\xaa\xba\xa2A" + - "\xf4\xcbx\xb1\x98q\x1c\xb5\x10\xad=.\xb1s\xfb\x99" + - "b;&\xb3\xe8j\x17\xa9\xb8\\yD\xd7\x95\x1a\xba" + - "\x95\x81\xb2\x19\xc5\x82\xb8\xde1o\xf9\x02\xc9K\x1e" + - "\xde\xa1\x8fwEo}\x8d\xe4\x1b\x92x\xe7\xe0\xf0\x08" + - "\xf8\x15x\x1f\xef\xee\xf6pj\x1b\xc9w{x\x97\xf2" + - "\xf1n\x17>\x09\x90\xdbM\xf2\x83\x1e\xde\xa5}\xbc;" + - "\x80\xcf\x00\xe4\x0e\x92\xfc\x11\x0f\xef*|\xbc;\xea\xe9" + - "?\x12\xe1\xec\xe4\x16\x1f\xef\x8ey\xf8\x18\xe1\xac\xeb\x98" + - "Z\xce6U\x1dp \xce\x8d|\xe9\xdb\x8c\x95\x9a!" + - "\xa3\xa9\xebXT\x8b\x0a\xaa\xa2\xb59\x8a\x06u9[" + - "\xc9\xaf\x89\xa9\xbdf\xb5+z\xc1\xc2Ae\x0d\xa3\x0a" + - "&$k\xbd\xadY+\x99\xa9\xf6\x03\xc6\xcd@\xc4}" + - "2\x9d\x86QN\x89*`\xfc" + - "\xcc\x82\xe1\xab\x8a\xf8\xa0\x09\x9c\xb8O@.z\x84\xc4" + - "\xf0\x01Q\xdc1\x0c\x9c\xb8]@>z\x17\xc4p\x18" + - "\x7f\xc3\xd0$\x04N\xbcK\xc0T\xf4J\x8a\xe1(_" + - "\\K\xdcJ\x150\x1d=9b\xf8^$\xde\xb1\x15" + - "8\xb1Gp\xc3\x16\x0a\x1a\xfd{4\xa1\x1b\"\x06\xd4" + - "y\x98\xd1\x84n8\xc1\xc2\xb0\xd5\x02hB7\x9c\xc3" + - "\xf0\x17\x1b\xc4xZ\xe1|\x172y\xc5fM\xd4\xbb" + - "\xfa\xc0\x8e\x01\xb2C\x13&\xe7\xa6\xfc\xc5\x1a\xa6\xb1\x89" + - "wKL\x0e\xa3\xc1\xd7p\xcc\x0d\xa3&u\xd7cI" + - "\xde\x1d\xccZ\x0el\x0d&5\xc7\x13\xb3\x96cD\xc6" + - "\x8f\xf3(\xbf\xca\xc5\x8c\"\x0c\xf8p\xd4\x88\x86\x19v" + - "\xcd\xe3L\x1c\x83\xb4\x088q\xf9\xdc\xd1-\x18\x83\x1e" + - "gF\x7f)\x0b\xe2Z\x91\x1cFNM\x0c#1\xec" + - "\xd7\x85\x11\xa5%9\x9a\x9c:A\xf3\x97\xec>\xbdZ" + - "\x97\xf2\xe25|z\xc5\xf0\x99\\\x14)\xee\xaa\x057" + - "\xecP1,\x94P\xe6\xb2\xcbl\xd3\xbbX\xdd\x97\xa9" + - "\xe4c\x04\x88\xbfO\x86\xa2\xd5\xbfP\xb4\xee\xea\xc4\xdc" + - "O3\x82\x0e3\xb3<\xd9$\x8cc+\xff\xc0!\xa5" + - "\xcf\xd0\xc7\xb4\xfeU\xd1\xfa\xa7\xe7&\xe6ra\xfc\xbd" + - "F\xc2Wy\x94\xdfH\xf4}g\x97\x02\xc8\xaf\xf3(" + - "\x7f\x1c\xbfC]\xa0@\xfd\x98\xc7\xae\x04\x7f\x17?'" + - "\xc5\xcf\x88\xe5&\xabY\x1a\xef\x07\xc8UR\xf5\xa8\xf1" + - "\xaaY\xca\xaff\"\xf6\x01\xe4\xb2$\x9f\x99d\xef\xd3" + - "\xb1\x17 WK\xf2y\x18\xb4\xeb\xe1\x1b\x96c\xc6\xc8" + - "\xaf\x19\x03\xcbT}LJ\x18>\x8c\xa1Mx\xea\x98" + - "T\x14F\x82oG[\x82$G3)df\x8eR" + - "\xbc\x80V4\xeb\xb9\x8c\x99\xf18\xee\xc8\x05\xc9\xe7\xe7" + - "^@4\x12\x93\x82#\x89!Z\xe8\x0c\xf9\x99`8" + - "ug\xc2\x19w\xf4\x01\xc8\xabx\x94\x079\x0f\xa0\x8c" + - "\x9eRAA\x9b-1\xd9Z\x87\x09z~(\xee\x98" + - "\xa9g\xcc[=X\"\xb6\xbe\xc4d\x8dk\x1d\x96T" + - "\x08\xdfH@P\x8d\xc2\xa8\xc7\x911h\xe7\xad\xac/" + - "g\xe4\xd70{\xc4\xdbQ\xd9\xfbfW\xfc@\x12=" + - "ov%\x9f7\x03X[K\x01^\xe2Q\xde\x94\x80" + - "\xb5\xa1\xe1\xb8\xdd\x1e\x9bg\xfc\xdfP\x83\xdf\xeb\x89\x8f" + - "X\xb6p)\x0c4\xfa\xa7Ge\xf9_\xf5e\x9f\x07" + - "\xc2\xe7\x97\x09O\x10\xbdh_\xe6H\x0d\"\x10\xc2\xc4" + - "\xbfX\xa1M\xb8`\xf1\xff\x0d\x00\x00\xff\xff\xcb\x86\x19" + - "\x8c" +const schema_db8274f9144abc7e = "x\xda\xccX}\x8c\x14g\x19\x7f~\xf3\xee\xee\xdcq" + + "\xbb\xecMf\x89pis\x86\xd0\xd4\x12[\x8b'\x86" + + "\xe2\xc7\xdd\xd1\x03=\xe4c\xe7\x16LK\xa9\xe9\xdc\xde" + + "{\xc7\x9c\xbb3\xdb\x99\xd9+\x87\xa5\x85\x0b\xa4\xa5\xc1" + + "\xdaR0\x05[\x834\xc6T\x8d\x16?\xa254\xa1" + + "\xd1\xd8\x9a6V\x0c\x1a\xa84j)ilJP\xc4" + + "\x98\x9a\xea\x98gvgv8Z\x0a\xe5\x9f\xfe\xb7\xf7" + + "\x9b\xe7}\xbe\xdf\xe7\xf7\xbcw\xe3\x89T\x9f\xb2 \xfd" + + "z\x86\xc8(\xa63\x81\x9c\xff\xfbM\xfb\xaf\xf9\xe5\x14" + + "\x19]@p\xcf\xa1\xe5\x85\xb7\xfc\xa9?QZ\xa8D" + + "=\xb7\x8aM\xd0\xab\xfcS\xb7\xc4\xeb\x84\xe0\xd3\xd5\x97" + + "\x0e|r\xcf\x0b\xdbH\xebRZ\xc2\x84\x9e\x95\xa9M" + + "\xd0\xcd\x14K\xde\x9eZM\x08\xfe\xb9{\xf6\xf7\xbe\xf5" + + "\xdb\xe7\xb7\x93v-\xa8\xa9\xae\x9ez\x19\x04}G\xea" + + "\x87\x84\xe0\xa5\x8f\x1e\xfa\xc5C?\xbe\xef\x1bd\\\x0b" + + "\x10\xf1\xd1\x9e\xeb\xd2\xffa\x81\xcf\xa4{\x09\xc1\xeec" + + "\xcf\xac\xaa>\xbc\xef@CC\xf8]\xa6\x15\x85R\xc1" + + "\xb6\xc1\x7fW\xd7>Qz\xa2\xa9;\x1d\xba\x9a>\x0b" + + "BO5\xdd\x0dB\xb0\xf0\xe5S\xabW\xfeh\xf4;" + + "\x89\xb3;2\x9b\xf8\xec\xacA\x9c8\xbc \xf5\xb3\xa4" + + "_\xdb3o\xb0\xd9\xbd\x19\xf6\xeb\xea\xd3Kr\xf6\x99" + + "\xa9\xc3\xa4u]\x90\x8f\x9b\xd4\xe5\xd0W\xaa\x1c\xe5\xa0" + + "\xca\xc2\xcbo{dW\xfa\xd4#\xcfq\xf6\x12\x09I" + + "\xb7\xb1\xf4)\xd5\x85\xfe\x16K\xf7\xfcK\xfd\x90 \x04" + + "]O}\xea\x07KF\x8e\xbf0M\xb7\xc2\x0a\xeb\x1d" + + "g\xf5\xad\x1d\xfcks\xc7]\x84\xe0\xe4\xf5\x07\xbf\xf2" + + "\xb7\xaf\x1e9\xdat\x14\xac\xe6xG\x98\x9f\xd3\x1d\x9c" + + "\x1f\xe5\x949g\xcb\x1f?{\"\x11c.\xfb*(" + + "\x15\xac\xfa\xe2m\xe3\xed\x9bO\x9eL\x1eE6\x8cq" + + "V\x96\x8f.\xbc\xa3_\xae_t\xcb\x1b\xa4u\x89\xf3" + + "\xca\xb80\xbb\x18\xfa\xd2,\x1f\xe8\xcf\xde\x07\xfd\xd6\x9c" + + "J\x14{6\xa9\xaf?\xc7" + + "\xf9\xd6\xd7\xe6X\xdf\xe8\xa27?w\xcd\x83\xbf>;" + + "-\xaeP\xb0\x9e\x9b\x0f};\xeb\xd1\xb7\xb2\xf0\x99e" + + "\xdf<\xda\x95\xef:7\xad\xdf2,\xfb\xed\xdc8\xf4" + + "\xa7Y\xb6\xe7\xa7\xb9\xe7\xb8\x90_W\x1f;\xb9\xe5\xcf" + + "_z;i\xfa\xc9\xfc\xabl\xfa\x99<\x9b\xbe\xfb\xcc" + + "\xde\xcf\x7fm\xfd\xf7\xff\x97\xc8\xc2+\xf9)\xae\xb4_" + + "\xb7mYqk\xa9\xf2\xc7\xa2\x9f\xe5\x1b\xcaf\xcd\xae" + + "-\xee\xaf\xfb\x1b\xa4\xed[e\xd3\x97C\xb2\xd7\xab9" + + "\xb6'\x8b\x80\xd1)RD)\x10i\xe68\x91q\x87" + + "\x80QQ\xa0\x01\x05\xeeQ\xcdbp\x83\x80\xe1+\xd0" + + "\x14\xa5\x00\x85H\xbbs.\x91Q\x1106*\x80(" + + "@\x10i\xf5]D\xc6F\x01c\x9b\x82\xa0&\xdd\xaa" + + "iK\x9b\xf2\xfeR\xd7E\x96\x14d\x09\x81+}w" + + "\xd2\x1c\xaeP^&`u\xfc.\x1f9R\x90#\x04" + + "\x1b\x9c\xba\xeb\xad\xb5}X\x95!9\xeaJ\x0f\x1b\x90" + + "!\x05\x19\xc2\xc5\xc2[\xba\xd1\xf2|\xcb\x1e[\x13\xe2" + + "\xbdE\xa7b\x95'9\xbcl\xe8\xf0\xd5\x8b\x89\x00m" + + "\xd6:\"(\x9a\xb6\x84\xa8\xd7\x1a\xb3\x1dW\x06#\x96" + + "Wvl[\x92(\xfb\xf7\x0e\x9b\x15\xd3.\xcb\xd8P" + + "\xe6BC\x0d\x03%\xe9NH\xf7\x063\x91\xd4yE" + + "\xd35E\xd53\xb2qB\x97\xae#2\x06\x04\x8cb" + + "\"\xa1+\x97\x13\x19+\x04\x8c[\x12\x09]\xbb\x84g" + + "\x93\x80\xb1^A\xe0\xb8\xd6\x98e\xdf,I\xb8\xc9\xbc" + + "x\xbemV%\x11Ey\xbb\xd7\xa9\xf9\x96c{\xe8" + + "l]J\x02:\x13\x99z\xaf\x00\xea\xb6+\xc7,\xcf" + + "\x97n\x03\x9e\xd7\xcbQT=#\x15\x07\x91\xdbGd" + + "t\x0a\x18W)\x08\xc6\\\xb3,\x8b\xd2\x85\xe5\x8c\xac" + + "2m\xa7$d\x19iR\x90N\x18\x9dy\xb9F\x87" + + "\xa4W\xaf\xf8\x1e\xc5\xa7.~\xde\x95a\xc5\xca~\xf3" + + "x\xb1\xbb\xe1s!\xf6y\xf3\xdcV/\xc6\x89\xdf:" + + "Ldl\x110v&\x12\xbf\x83Kt\xbf\x80\xb1[" + + "\x81&\x9a\xad\xfc0\x97\xe8!\x01\xe31\x05Z*U" + + "@\x8aH\xdb\xcb%\xda-`\xecW\xce\xefX9!" + + "m\x7f\xc0\x1a#Uz-\x94]\x1c\xb0\xc6$\x09\xef" + + "J\x8b\xd8\xf6\x1e\xf9p\x86=\xa7\"}9 \xcb\x15" + + "\xd35}kB6\xbe\xdf\xdcHST\xd4K\xee\x8a" + + "i\xe5)\x9a\xf90\xbf\x1f\xa4\xc6\xbe\xf8\x84\xb3\x1c\x9b" + + "(\xbc\xfd-\x97\xb9%\xfa\x04\x8c\x15\x09\x97\x07?\x9e" + + "\x88#ry\xe5p+\x0e\xf5\xcbr2\xf2\xaa[V" + + "M\xab\x12\xcf\xb2f0\xfd\xa4~\xa1%s1\xff\x86" + + "\xc2\xac\xba\xa1w\xabk\xdda\x84\xec\xe3\xa2\xc8G}" + + "\x12\xcb\x89J\x1b!P\xda\x86\x96\x9b\xfaV,!*" + + "\xdd\xcd\xf8\xfdhy\xaaoG\x17Qi\x0b\xe3;\x11" + + "Ob}\x07\xbeKT\xda\xc9\xf0\xa3,\x9e\x12a\x07" + + "\xeb{B\xf5\xbb\x19\xdf\xcfx:U@\x9aH\x7f\x1c" + + "\xf3\x89J\x8f2\xfe\x13\xc63J\x01\x19\"\xfd \xc6" + + "\x89JO1~\x88q5]`2\xd2\x9f\x86KT" + + "\xfa9\xe3\xbfb\xbcmv\x01mD\xfa\xb3!~\x98" + + "\xf1\x17\x19o\x9fS@;\x91\xfe\x1bL\x11\x95\x9eg" + + "\xfc(\xe33P\xc0\x0c\"\xfd\x08\xf6\x11\x95\x8e2\xfe" + + "\x17\xc6;2\x05t\x10\xe9\xaf\x84\xfe\x1cc\xfc5\xc6" + + "\xb3\xa9\x02\xb2D\xfa_q\x80\xa8\xf4\x1a\xe3\x7fg<" + + "\xa7\x16\x90#\xd2O\x87q\xbd\xc9x\x9b\xa2 (W" + + ",i\xfb\x83#\xc9\x8e\x9a\x90\xaeg9v\xf4\xb7p" + + "\xbc\xb8d\xb2I\x1dh\xb4{\xd1\xc93w \xdf\xda" + + "\xfc\x08\xc8\x13\x82\x9a\xe3TV\x9d\xdf\xa9y\xdf\x1c\xf3" + + "0\x93P\x14@gk\xd9!0\x184\xe7\x94Ey" + + "\xc7\x1e\x1c\x89y\xac\xd1:+\x1c\xea.\x9b\x95\xc1Z" + + "\xec\x89\xe5\xf5\xd7}\xa7^\xa3\xee\x11\xd3\x97#\x00)" + + "\xe0\x8d\xc0\xad\xdb\xcb\\\xa7\xba\x06\xd2\xadZ\xb6Y\xa1" + + "\xf8K\xd9\xa9\xd6\\\xe9y\xb0\x1c\xdb\xa8\x9b\x15K\xf8" + + "\x93h'\x05\xed\x84|\xbdn\x8d\xc4\xba\xedz\xb5\xe8" + + "\xca\x09\x0bN\xdd\xeb\xf7}YUk\xbe\x17{4*" + + "M\xbf\xeeJ\x8fCkF\xc3\x07g&:Z\x99\xde" + + "\xd1\xdd\xb5\xc5k\xcc1\xee\xe0\xb6\xf8\x96]7\x9f\xc8" + + "\x98'`\xdc\x98\xb8e\xd7\xf3-\xfb\x88\x80\xf1\x09\x05" + + "y\xbe\xea\xf1\x8d\x9a0+uy\xc1\xdd\xc9\\\xe6\xfc" + + "\x1f\xeam\xf0G\x92\xb4\x16\x13\x19m\x02FAA\xaf" + + "\x1b~Fg\xb4\x86]&G\x8eI\xbf\xf1k\xd0\x1e" + + "u\x98\xe5\xd5\xcb\x99\xa5\xe7\x9f\x1e\x92^\xfeR\\m" + + "\xad\x97\xd3\x9c\x15\xeff\xae\xb7a\x85\xcb1[\xa4\x89" + + "\xe2\xad\x1f\xd1*\xab\x1d\xdcD\x8a\xf6\xa4\x8a\xd6\x1e\x8d" + + "hm\xd6\x1ewI\xd1\xf6\xa8P\xe2G\x0a\xa2\xc7\x88" + + "\xb6\xe3\x01R\xb4\xed*D\xfc\xc6@\xb4\x82.\x98\x9c" + + "\x01R\xb4\xcd*R\xf1\xf3\x07\xd1\x02\xab\xdd9N\x8a" + + "f\xa9H\xc7\xcf\x17D+\xbev\xfb\x14)\xdaZ5" + + "\x88\xb8\x86z\x1bq\xf4!\x88RF\xdda\xd2\xfa\x10" + + "D\x1b\x03\"N\"\xeaC\x10\xf1\x9ex7\xe2\x0b\xa5" + + "\xa2\x1d\x8d\xf2\xbc\xa5\xf5\xf1\x12\xdah\x1f4\xfb\x87\xfa" + + "P\x04\xde/9\x0e\xc9\xee+i\xbew\xa8g\xc3N" + + "\x9eC\xe7j&\xf4\xf2*\x9e\x150f+\x08*N" + + "\x93\xe7\xf2\xab\x127\xeab\xfc\xd3p8b\xa1<\x1f" + + "f\xfd\x1f\x8e\xf5\x1fa\x8a|Q\xc08\x96\xb8\xbc\x7f" + + "`\xf0w\x02\xc6\x89\x04E\x1eg\xaa?&`\x9ck" + + "\xed\xff\xffx\x80\xc88'0\x94\xa0\x1c\xed\xbf,\xf8" + + "6\x0f\xe6\x90p\xd0 \x9c4v\x11\x95\xdax`\x17" + + "B\xc2I5\x08G\xc30Q\xa9\x93\xf1\xab\x92\x843" + + "\x07\xeb\x88J\xb3\x19\x9f\x07\x05\xaaL\xbc\x1d\xean\x8b" + + "\x92+\xce\xd8\x0a\xcb~\xc7)\x16=H\xe0/3\xad" + + "J\xdd\x95\xd4\x1a\xa2\x8dD\x0d\x0e$\xe6z\xe3\xa5\xd2" + + "?\xca\x1dW\xe2~\x19\x81\x07\x95\x14\xa8\x97\xb7\xf0\xbd" + + "\xaf\x87\x04\xaf\xc3\xea\xa5\x0c\x89\xf8\x1f\x19\xd3\x9a\xaa\xfd" + + "J\x17\xc6h!\xff\x7f\x00\x00\x00\xff\xff/\xf3\xa2\xe2" func init() { schemas.Register(schema_db8274f9144abc7e, 0x82c325a07ad22a65, - 0x8407e070e0d52605, 0x84cb9536a2cf6d3c, 0x85c8cea1ab1894f3, - 0x8891f360e47c30d3, - 0x91f7a001ca145b9d, 0x9b87b390babc2ccf, - 0x9e12cfad042ba4f1, 0xa29a916d4ebdd894, 0xa353a3556df74984, 0xa766b24d4fe5da35, - 0xa78f37418c1077c8, - 0xaa7386f356bd398a, - 0xb14ce48f4e2abb0d, - 0xb167b0bebe562cd0, 0xb70431c0dc014915, - 0xb9d4ef45c2b5fc5b, - 0xbe403adc6d018a5a, 0xc082ef6e0d42ed1d, - 0xc744e349009087aa, - 0xc766a92976e389c4, 0xc793e50592935b4a, 0xcbd96442ae3bb01a, 0xd4d18de97bb12de3, - 0xd58a254e7a792b87, 0xdc3ed6801961e502, 0xe3e37d096a5b564e, - 0xe4a6a1bc139211b4, - 0xea20b390b257d1a5, 0xea58385c65416035, - 0xf0a143f1c95a678e, - 0xf143a395ed8b3133, 0xf2c122394f447e8e, 0xf2c68e2547ec3866, 0xf41a0f001ad49e46, - 0xf7f49b3f779ae258, - 0xf9c895683ed9ac4c, 0xfc5edf80e39c0796, - 0xfeac5c8f4899ef7c, - 0xff8d9848747c956a) + 0xfeac5c8f4899ef7c) }