cloudflared-mirror/tunnelrpc/tunnelrpc.capnp.go

4453 lines
150 KiB
Go
Raw Normal View History

// Code generated by capnpc-go. DO NOT EDIT.
package tunnelrpc
import (
context "golang.org/x/net/context"
strconv "strconv"
capnp "zombiezen.com/go/capnproto2"
text "zombiezen.com/go/capnproto2/encoding/text"
schemas "zombiezen.com/go/capnproto2/schemas"
server "zombiezen.com/go/capnproto2/server"
)
type Authentication struct{ capnp.Struct }
// Authentication_TypeID is the unique identifier for the type Authentication.
const Authentication_TypeID = 0xc082ef6e0d42ed1d
func NewAuthentication(s *capnp.Segment) (Authentication, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return Authentication{st}, err
}
func NewRootAuthentication(s *capnp.Segment) (Authentication, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return Authentication{st}, err
}
func ReadRootAuthentication(msg *capnp.Message) (Authentication, error) {
root, err := msg.RootPtr()
return Authentication{root.Struct()}, err
}
func (s Authentication) String() string {
str, _ := text.Marshal(0xc082ef6e0d42ed1d, s.Struct)
return str
}
func (s Authentication) Key() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Authentication) HasKey() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Authentication) KeyBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Authentication) SetKey(v string) error {
return s.Struct.SetText(0, v)
}
func (s Authentication) Email() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s Authentication) HasEmail() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s Authentication) EmailBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s Authentication) SetEmail(v string) error {
return s.Struct.SetText(1, v)
}
func (s Authentication) OriginCAKey() (string, error) {
p, err := s.Struct.Ptr(2)
return p.Text(), err
}
func (s Authentication) HasOriginCAKey() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s Authentication) OriginCAKeyBytes() ([]byte, error) {
p, err := s.Struct.Ptr(2)
return p.TextBytes(), err
}
func (s Authentication) SetOriginCAKey(v string) error {
return s.Struct.SetText(2, v)
}
// Authentication_List is a list of Authentication.
type Authentication_List struct{ capnp.List }
// NewAuthentication creates a new list of Authentication.
func NewAuthentication_List(s *capnp.Segment, sz int32) (Authentication_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
return Authentication_List{l}, err
}
func (s Authentication_List) At(i int) Authentication { return Authentication{s.List.Struct(i)} }
func (s Authentication_List) Set(i int, v Authentication) error { return s.List.SetStruct(i, v.Struct) }
// Authentication_Promise is a wrapper for a Authentication promised by a client call.
type Authentication_Promise struct{ *capnp.Pipeline }
func (p Authentication_Promise) Struct() (Authentication, error) {
s, err := p.Pipeline.Struct()
return Authentication{s}, err
}
type TunnelRegistration struct{ capnp.Struct }
// TunnelRegistration_TypeID is the unique identifier for the type TunnelRegistration.
const TunnelRegistration_TypeID = 0xf41a0f001ad49e46
func NewTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5})
return TunnelRegistration{st}, err
}
func NewRootTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5})
return TunnelRegistration{st}, err
}
func ReadRootTunnelRegistration(msg *capnp.Message) (TunnelRegistration, error) {
root, err := msg.RootPtr()
return TunnelRegistration{root.Struct()}, err
}
func (s TunnelRegistration) String() string {
str, _ := text.Marshal(0xf41a0f001ad49e46, s.Struct)
return str
}
func (s TunnelRegistration) Err() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s TunnelRegistration) HasErr() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) ErrBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s TunnelRegistration) SetErr(v string) error {
return s.Struct.SetText(0, v)
}
func (s TunnelRegistration) Url() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s TunnelRegistration) HasUrl() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) UrlBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s TunnelRegistration) SetUrl(v string) error {
return s.Struct.SetText(1, v)
}
func (s TunnelRegistration) LogLines() (capnp.TextList, error) {
p, err := s.Struct.Ptr(2)
return capnp.TextList{List: p.List()}, err
}
func (s TunnelRegistration) HasLogLines() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) SetLogLines(v capnp.TextList) error {
return s.Struct.SetPtr(2, v.List.ToPtr())
}
// NewLogLines sets the logLines field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s TunnelRegistration) NewLogLines(n int32) (capnp.TextList, error) {
l, err := capnp.NewTextList(s.Struct.Segment(), n)
if err != nil {
return capnp.TextList{}, err
}
err = s.Struct.SetPtr(2, l.List.ToPtr())
return l, err
}
func (s TunnelRegistration) PermanentFailure() bool {
return s.Struct.Bit(0)
}
func (s TunnelRegistration) SetPermanentFailure(v bool) {
s.Struct.SetBit(0, v)
}
func (s TunnelRegistration) TunnelID() (string, error) {
p, err := s.Struct.Ptr(3)
return p.Text(), err
}
func (s TunnelRegistration) HasTunnelID() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) TunnelIDBytes() ([]byte, error) {
p, err := s.Struct.Ptr(3)
return p.TextBytes(), err
}
func (s TunnelRegistration) SetTunnelID(v string) error {
return s.Struct.SetText(3, v)
}
func (s TunnelRegistration) RetryAfterSeconds() uint16 {
return s.Struct.Uint16(2)
}
func (s TunnelRegistration) SetRetryAfterSeconds(v uint16) {
s.Struct.SetUint16(2, v)
}
func (s TunnelRegistration) EventDigest() ([]byte, error) {
p, err := s.Struct.Ptr(4)
return []byte(p.Data()), err
}
func (s TunnelRegistration) HasEventDigest() bool {
p, err := s.Struct.Ptr(4)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) SetEventDigest(v []byte) error {
return s.Struct.SetData(4, v)
}
// TunnelRegistration_List is a list of TunnelRegistration.
type TunnelRegistration_List struct{ capnp.List }
// NewTunnelRegistration creates a new list of TunnelRegistration.
func NewTunnelRegistration_List(s *capnp.Segment, sz int32) (TunnelRegistration_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5}, sz)
return TunnelRegistration_List{l}, err
}
func (s TunnelRegistration_List) At(i int) TunnelRegistration {
return TunnelRegistration{s.List.Struct(i)}
}
func (s TunnelRegistration_List) Set(i int, v TunnelRegistration) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelRegistration_Promise is a wrapper for a TunnelRegistration promised by a client call.
type TunnelRegistration_Promise struct{ *capnp.Pipeline }
func (p TunnelRegistration_Promise) Struct() (TunnelRegistration, error) {
s, err := p.Pipeline.Struct()
return TunnelRegistration{s}, err
}
type RegistrationOptions struct{ capnp.Struct }
// RegistrationOptions_TypeID is the unique identifier for the type RegistrationOptions.
const RegistrationOptions_TypeID = 0xc793e50592935b4a
func NewRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 8})
return RegistrationOptions{st}, err
}
func NewRootRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 8})
return RegistrationOptions{st}, err
}
func ReadRootRegistrationOptions(msg *capnp.Message) (RegistrationOptions, error) {
root, err := msg.RootPtr()
return RegistrationOptions{root.Struct()}, err
}
func (s RegistrationOptions) String() string {
str, _ := text.Marshal(0xc793e50592935b4a, s.Struct)
return str
}
func (s RegistrationOptions) ClientId() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s RegistrationOptions) HasClientId() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) ClientIdBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetClientId(v string) error {
return s.Struct.SetText(0, v)
}
func (s RegistrationOptions) Version() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s RegistrationOptions) HasVersion() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) VersionBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetVersion(v string) error {
return s.Struct.SetText(1, v)
}
func (s RegistrationOptions) Os() (string, error) {
p, err := s.Struct.Ptr(2)
return p.Text(), err
}
func (s RegistrationOptions) HasOs() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) OsBytes() ([]byte, error) {
p, err := s.Struct.Ptr(2)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetOs(v string) error {
return s.Struct.SetText(2, v)
}
func (s RegistrationOptions) ExistingTunnelPolicy() ExistingTunnelPolicy {
return ExistingTunnelPolicy(s.Struct.Uint16(0))
}
func (s RegistrationOptions) SetExistingTunnelPolicy(v ExistingTunnelPolicy) {
s.Struct.SetUint16(0, uint16(v))
}
func (s RegistrationOptions) PoolName() (string, error) {
p, err := s.Struct.Ptr(3)
return p.Text(), err
}
func (s RegistrationOptions) HasPoolName() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) PoolNameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(3)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetPoolName(v string) error {
return s.Struct.SetText(3, v)
}
func (s RegistrationOptions) Tags() (Tag_List, error) {
p, err := s.Struct.Ptr(4)
return Tag_List{List: p.List()}, err
}
func (s RegistrationOptions) HasTags() bool {
p, err := s.Struct.Ptr(4)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) SetTags(v Tag_List) error {
return s.Struct.SetPtr(4, v.List.ToPtr())
}
// NewTags sets the tags field to a newly
// allocated Tag_List, preferring placement in s's segment.
func (s RegistrationOptions) NewTags(n int32) (Tag_List, error) {
l, err := NewTag_List(s.Struct.Segment(), n)
if err != nil {
return Tag_List{}, err
}
err = s.Struct.SetPtr(4, l.List.ToPtr())
return l, err
}
func (s RegistrationOptions) ConnectionId() uint8 {
return s.Struct.Uint8(2)
}
func (s RegistrationOptions) SetConnectionId(v uint8) {
s.Struct.SetUint8(2, v)
}
func (s RegistrationOptions) OriginLocalIp() (string, error) {
p, err := s.Struct.Ptr(5)
return p.Text(), err
}
func (s RegistrationOptions) HasOriginLocalIp() bool {
p, err := s.Struct.Ptr(5)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) OriginLocalIpBytes() ([]byte, error) {
p, err := s.Struct.Ptr(5)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetOriginLocalIp(v string) error {
return s.Struct.SetText(5, v)
}
func (s RegistrationOptions) IsAutoupdated() bool {
return s.Struct.Bit(24)
}
func (s RegistrationOptions) SetIsAutoupdated(v bool) {
s.Struct.SetBit(24, v)
}
func (s RegistrationOptions) RunFromTerminal() bool {
return s.Struct.Bit(25)
}
func (s RegistrationOptions) SetRunFromTerminal(v bool) {
s.Struct.SetBit(25, v)
}
func (s RegistrationOptions) CompressionQuality() uint64 {
return s.Struct.Uint64(8)
}
func (s RegistrationOptions) SetCompressionQuality(v uint64) {
s.Struct.SetUint64(8, v)
}
func (s RegistrationOptions) Uuid() (string, error) {
p, err := s.Struct.Ptr(6)
return p.Text(), err
}
func (s RegistrationOptions) HasUuid() bool {
p, err := s.Struct.Ptr(6)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) UuidBytes() ([]byte, error) {
p, err := s.Struct.Ptr(6)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetUuid(v string) error {
return s.Struct.SetText(6, v)
}
func (s RegistrationOptions) NumPreviousAttempts() uint8 {
return s.Struct.Uint8(4)
}
func (s RegistrationOptions) SetNumPreviousAttempts(v uint8) {
s.Struct.SetUint8(4, v)
}
func (s RegistrationOptions) Features() (capnp.TextList, error) {
p, err := s.Struct.Ptr(7)
return capnp.TextList{List: p.List()}, err
}
func (s RegistrationOptions) HasFeatures() bool {
p, err := s.Struct.Ptr(7)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) SetFeatures(v capnp.TextList) error {
return s.Struct.SetPtr(7, v.List.ToPtr())
}
// NewFeatures sets the features field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s RegistrationOptions) NewFeatures(n int32) (capnp.TextList, error) {
l, err := capnp.NewTextList(s.Struct.Segment(), n)
if err != nil {
return capnp.TextList{}, err
}
err = s.Struct.SetPtr(7, l.List.ToPtr())
return l, err
}
// RegistrationOptions_List is a list of RegistrationOptions.
type RegistrationOptions_List struct{ capnp.List }
// NewRegistrationOptions creates a new list of RegistrationOptions.
func NewRegistrationOptions_List(s *capnp.Segment, sz int32) (RegistrationOptions_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 8}, sz)
return RegistrationOptions_List{l}, err
}
func (s RegistrationOptions_List) At(i int) RegistrationOptions {
return RegistrationOptions{s.List.Struct(i)}
}
func (s RegistrationOptions_List) Set(i int, v RegistrationOptions) error {
return s.List.SetStruct(i, v.Struct)
}
// RegistrationOptions_Promise is a wrapper for a RegistrationOptions promised by a client call.
type RegistrationOptions_Promise struct{ *capnp.Pipeline }
func (p RegistrationOptions_Promise) Struct() (RegistrationOptions, error) {
s, err := p.Pipeline.Struct()
return RegistrationOptions{s}, err
}
2019-03-18 23:14:47 +00:00
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})
2019-03-18 23:14:47 +00:00
return CapnpConnectParameters{st}, err
}
func NewRootCapnpConnectParameters(s *capnp.Segment) (CapnpConnectParameters, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5})
2019-03-18 23:14:47 +00:00
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)
}
2019-03-18 23:14:47 +00:00
// 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)
2019-03-18 23:14:47 +00:00
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)
}
// 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) + ")"
}
2019-03-18 23:14:47 +00:00
// 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})
2019-03-18 23:14:47 +00:00
return ConnectResult{st}, err
}
func NewRootConnectResult(s *capnp.Segment) (ConnectResult, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
2019-03-18 23:14:47 +00:00
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) {
2019-03-18 23:14:47 +00:00
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
}
2019-03-18 23:14:47 +00:00
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s ConnectResult_result) SetErr(v ConnectError) error {
s.Struct.SetUint16(0, 0)
2019-03-18 23:14:47 +00:00
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)
2019-03-18 23:14:47 +00:00
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) {
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
}
2019-03-18 23:14:47 +00:00
// 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)
2019-03-18 23:14:47 +00:00
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) }
// 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
2019-03-18 23:14:47 +00:00
}
func (p ConnectResult_result_Promise) Err() ConnectError_Promise {
return ConnectError_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
2019-03-18 23:14:47 +00:00
}
func (p ConnectResult_result_Promise) Success() ConnectSuccess_Promise {
return ConnectSuccess_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
2019-03-18 23:14:47 +00:00
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) }
// 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) }
// 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) }
// 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)
}
// 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)
}
// 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) {
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) {
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) {
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)
}
// 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)
}
// 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)
}
// 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) }
// 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
2019-03-18 23:14:47 +00:00
}
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
2019-03-18 23:14:47 +00:00
}
func NewRootHelloWorldOriginConfig(s *capnp.Segment) (HelloWorldOriginConfig, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
return HelloWorldOriginConfig{st}, err
2019-03-18 23:14:47 +00:00
}
func ReadRootHelloWorldOriginConfig(msg *capnp.Message) (HelloWorldOriginConfig, error) {
root, err := msg.RootPtr()
return HelloWorldOriginConfig{root.Struct()}, err
2019-03-18 23:14:47 +00:00
}
func (s HelloWorldOriginConfig) String() string {
str, _ := text.Marshal(0x8891f360e47c30d3, s.Struct)
return str
2019-03-18 23:14:47 +00:00
}
// HelloWorldOriginConfig_List is a list of HelloWorldOriginConfig.
type HelloWorldOriginConfig_List struct{ capnp.List }
2019-03-18 23:14:47 +00:00
// 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
2019-03-18 23:14:47 +00:00
}
func (s HelloWorldOriginConfig_List) At(i int) HelloWorldOriginConfig {
return HelloWorldOriginConfig{s.List.Struct(i)}
}
2019-03-18 23:14:47 +00:00
func (s HelloWorldOriginConfig_List) Set(i int, v HelloWorldOriginConfig) error {
return s.List.SetStruct(i, v.Struct)
}
2019-03-18 23:14:47 +00:00
// 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) {
2019-03-18 23:14:47 +00:00
s, err := p.Pipeline.Struct()
return HelloWorldOriginConfig{s}, err
2019-03-18 23:14:47 +00:00
}
type Tag struct{ capnp.Struct }
// Tag_TypeID is the unique identifier for the type Tag.
const Tag_TypeID = 0xcbd96442ae3bb01a
func NewTag(s *capnp.Segment) (Tag, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
return Tag{st}, err
}
func NewRootTag(s *capnp.Segment) (Tag, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
return Tag{st}, err
}
func ReadRootTag(msg *capnp.Message) (Tag, error) {
root, err := msg.RootPtr()
return Tag{root.Struct()}, err
}
func (s Tag) String() string {
str, _ := text.Marshal(0xcbd96442ae3bb01a, s.Struct)
return str
}
func (s Tag) Name() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Tag) HasName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Tag) NameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Tag) SetName(v string) error {
return s.Struct.SetText(0, v)
}
func (s Tag) Value() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s Tag) HasValue() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s Tag) ValueBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s Tag) SetValue(v string) error {
return s.Struct.SetText(1, v)
}
// Tag_List is a list of Tag.
type Tag_List struct{ capnp.List }
// NewTag creates a new list of Tag.
func NewTag_List(s *capnp.Segment, sz int32) (Tag_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
return Tag_List{l}, err
}
func (s Tag_List) At(i int) Tag { return Tag{s.List.Struct(i)} }
2019-03-18 23:14:47 +00:00
func (s Tag_List) Set(i int, v Tag) error { return s.List.SetStruct(i, v.Struct) }
// Tag_Promise is a wrapper for a Tag promised by a client call.
type Tag_Promise struct{ *capnp.Pipeline }
func (p Tag_Promise) Struct() (Tag, error) {
s, err := p.Pipeline.Struct()
return Tag{s}, err
}
type ExistingTunnelPolicy uint16
// ExistingTunnelPolicy_TypeID is the unique identifier for the type ExistingTunnelPolicy.
const ExistingTunnelPolicy_TypeID = 0x84cb9536a2cf6d3c
// Values of ExistingTunnelPolicy.
const (
ExistingTunnelPolicy_ignore ExistingTunnelPolicy = 0
ExistingTunnelPolicy_disconnect ExistingTunnelPolicy = 1
ExistingTunnelPolicy_balance ExistingTunnelPolicy = 2
)
// String returns the enum's constant name.
func (c ExistingTunnelPolicy) String() string {
switch c {
case ExistingTunnelPolicy_ignore:
return "ignore"
case ExistingTunnelPolicy_disconnect:
return "disconnect"
case ExistingTunnelPolicy_balance:
return "balance"
default:
return ""
}
}
// ExistingTunnelPolicyFromString returns the enum value with a name,
// or the zero value if there's no such value.
func ExistingTunnelPolicyFromString(c string) ExistingTunnelPolicy {
switch c {
case "ignore":
return ExistingTunnelPolicy_ignore
case "disconnect":
return ExistingTunnelPolicy_disconnect
case "balance":
return ExistingTunnelPolicy_balance
default:
return 0
}
}
type ExistingTunnelPolicy_List struct{ capnp.List }
func NewExistingTunnelPolicy_List(s *capnp.Segment, sz int32) (ExistingTunnelPolicy_List, error) {
l, err := capnp.NewUInt16List(s, sz)
return ExistingTunnelPolicy_List{l.List}, err
}
func (l ExistingTunnelPolicy_List) At(i int) ExistingTunnelPolicy {
ul := capnp.UInt16List{List: l.List}
return ExistingTunnelPolicy(ul.At(i))
}
func (l ExistingTunnelPolicy_List) Set(i int, v ExistingTunnelPolicy) {
ul := capnp.UInt16List{List: l.List}
ul.Set(i, uint16(v))
}
type ServerInfo struct{ capnp.Struct }
// ServerInfo_TypeID is the unique identifier for the type ServerInfo.
const ServerInfo_TypeID = 0xf2c68e2547ec3866
func NewServerInfo(s *capnp.Segment) (ServerInfo, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return ServerInfo{st}, err
}
func NewRootServerInfo(s *capnp.Segment) (ServerInfo, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return ServerInfo{st}, err
}
func ReadRootServerInfo(msg *capnp.Message) (ServerInfo, error) {
root, err := msg.RootPtr()
return ServerInfo{root.Struct()}, err
}
func (s ServerInfo) String() string {
str, _ := text.Marshal(0xf2c68e2547ec3866, s.Struct)
return str
}
func (s ServerInfo) LocationName() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s ServerInfo) HasLocationName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s ServerInfo) LocationNameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s ServerInfo) SetLocationName(v string) error {
return s.Struct.SetText(0, v)
}
// ServerInfo_List is a list of ServerInfo.
type ServerInfo_List struct{ capnp.List }
// NewServerInfo creates a new list of ServerInfo.
func NewServerInfo_List(s *capnp.Segment, sz int32) (ServerInfo_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return ServerInfo_List{l}, err
}
func (s ServerInfo_List) At(i int) ServerInfo { return ServerInfo{s.List.Struct(i)} }
func (s ServerInfo_List) Set(i int, v ServerInfo) error { return s.List.SetStruct(i, v.Struct) }
// ServerInfo_Promise is a wrapper for a ServerInfo promised by a client call.
type ServerInfo_Promise struct{ *capnp.Pipeline }
func (p ServerInfo_Promise) Struct() (ServerInfo, error) {
s, err := p.Pipeline.Struct()
return ServerInfo{s}, err
}
type 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)
}
// 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) {
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) {
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) {
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) {
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) }
// 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.
const AuthenticateResponse_TypeID = 0x82c325a07ad22a65
func NewAuthenticateResponse(s *capnp.Segment) (AuthenticateResponse, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
return AuthenticateResponse{st}, err
}
func NewRootAuthenticateResponse(s *capnp.Segment) (AuthenticateResponse, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
return AuthenticateResponse{st}, err
}
func ReadRootAuthenticateResponse(msg *capnp.Message) (AuthenticateResponse, error) {
root, err := msg.RootPtr()
return AuthenticateResponse{root.Struct()}, err
}
func (s AuthenticateResponse) String() string {
str, _ := text.Marshal(0x82c325a07ad22a65, s.Struct)
return str
}
func (s AuthenticateResponse) PermanentErr() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s AuthenticateResponse) HasPermanentErr() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s AuthenticateResponse) PermanentErrBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s AuthenticateResponse) SetPermanentErr(v string) error {
return s.Struct.SetText(0, v)
}
func (s AuthenticateResponse) RetryableErr() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s AuthenticateResponse) HasRetryableErr() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s AuthenticateResponse) RetryableErrBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s AuthenticateResponse) SetRetryableErr(v string) error {
return s.Struct.SetText(1, v)
}
func (s AuthenticateResponse) Jwt() ([]byte, error) {
p, err := s.Struct.Ptr(2)
return []byte(p.Data()), err
}
func (s AuthenticateResponse) HasJwt() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s AuthenticateResponse) SetJwt(v []byte) error {
return s.Struct.SetData(2, v)
}
func (s AuthenticateResponse) HoursUntilRefresh() uint8 {
return s.Struct.Uint8(0)
}
func (s AuthenticateResponse) SetHoursUntilRefresh(v uint8) {
s.Struct.SetUint8(0, v)
}
// AuthenticateResponse_List is a list of AuthenticateResponse.
type AuthenticateResponse_List struct{ capnp.List }
// NewAuthenticateResponse creates a new list of AuthenticateResponse.
func NewAuthenticateResponse_List(s *capnp.Segment, sz int32) (AuthenticateResponse_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}, sz)
return AuthenticateResponse_List{l}, err
}
func (s AuthenticateResponse_List) At(i int) AuthenticateResponse {
return AuthenticateResponse{s.List.Struct(i)}
}
func (s AuthenticateResponse_List) Set(i int, v AuthenticateResponse) error {
return s.List.SetStruct(i, v.Struct)
}
// AuthenticateResponse_Promise is a wrapper for a AuthenticateResponse promised by a client call.
type AuthenticateResponse_Promise struct{ *capnp.Pipeline }
func (p AuthenticateResponse_Promise) Struct() (AuthenticateResponse, error) {
s, err := p.Pipeline.Struct()
return AuthenticateResponse{s}, err
}
type TunnelServer struct{ Client capnp.Client }
// TunnelServer_TypeID is the unique identifier for the type TunnelServer.
const TunnelServer_TypeID = 0xea58385c65416035
func (c TunnelServer) RegisterTunnel(ctx context.Context, params func(TunnelServer_registerTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_registerTunnel_Results_Promise {
if c.Client == nil {
return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 0,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "registerTunnel",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 3}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_registerTunnel_Params{Struct: s}) }
}
return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
func (c TunnelServer) GetServerInfo(ctx context.Context, params func(TunnelServer_getServerInfo_Params) error, opts ...capnp.CallOption) TunnelServer_getServerInfo_Results_Promise {
if c.Client == nil {
return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 1,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "getServerInfo",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_getServerInfo_Params{Struct: s}) }
}
return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
func (c TunnelServer) UnregisterTunnel(ctx context.Context, params func(TunnelServer_unregisterTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_unregisterTunnel_Results_Promise {
if c.Client == nil {
return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 2,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "unregisterTunnel",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 0}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_unregisterTunnel_Params{Struct: s}) }
}
return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
2019-03-18 23:14:47 +00:00
func (c TunnelServer) Connect(ctx context.Context, params func(TunnelServer_connect_Params) error, opts ...capnp.CallOption) TunnelServer_connect_Results_Promise {
if c.Client == nil {
return TunnelServer_connect_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 3,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
2019-03-18 23:14:47 +00:00
MethodName: "connect",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_connect_Params{Struct: s}) }
}
return TunnelServer_connect_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
func (c TunnelServer) Authenticate(ctx context.Context, params func(TunnelServer_authenticate_Params) error, opts ...capnp.CallOption) TunnelServer_authenticate_Results_Promise {
if c.Client == nil {
return TunnelServer_authenticate_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 4,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "authenticate",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 3}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_authenticate_Params{Struct: s}) }
}
return TunnelServer_authenticate_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
func (c TunnelServer) ReconnectTunnel(ctx context.Context, params func(TunnelServer_reconnectTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_reconnectTunnel_Results_Promise {
if c.Client == nil {
return TunnelServer_reconnectTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 5,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "reconnectTunnel",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 4}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_reconnectTunnel_Params{Struct: s}) }
}
return TunnelServer_reconnectTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
type TunnelServer_Server interface {
RegisterTunnel(TunnelServer_registerTunnel) error
GetServerInfo(TunnelServer_getServerInfo) error
UnregisterTunnel(TunnelServer_unregisterTunnel) error
2019-03-18 23:14:47 +00:00
Connect(TunnelServer_connect) error
Authenticate(TunnelServer_authenticate) error
ReconnectTunnel(TunnelServer_reconnectTunnel) error
}
func TunnelServer_ServerToClient(s TunnelServer_Server) TunnelServer {
c, _ := s.(server.Closer)
return TunnelServer{Client: server.New(TunnelServer_Methods(nil, s), c)}
}
func TunnelServer_Methods(methods []server.Method, s TunnelServer_Server) []server.Method {
if cap(methods) == 0 {
methods = make([]server.Method, 0, 6)
}
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 0,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "registerTunnel",
},
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
call := TunnelServer_registerTunnel{c, opts, TunnelServer_registerTunnel_Params{Struct: p}, TunnelServer_registerTunnel_Results{Struct: r}}
return s.RegisterTunnel(call)
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
})
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 1,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "getServerInfo",
},
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
call := TunnelServer_getServerInfo{c, opts, TunnelServer_getServerInfo_Params{Struct: p}, TunnelServer_getServerInfo_Results{Struct: r}}
return s.GetServerInfo(call)
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
})
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 2,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "unregisterTunnel",
},
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
call := TunnelServer_unregisterTunnel{c, opts, TunnelServer_unregisterTunnel_Params{Struct: p}, TunnelServer_unregisterTunnel_Results{Struct: r}}
return s.UnregisterTunnel(call)
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
})
2019-03-18 23:14:47 +00:00
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 3,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
2019-03-18 23:14:47 +00:00
MethodName: "connect",
},
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
call := TunnelServer_connect{c, opts, TunnelServer_connect_Params{Struct: p}, TunnelServer_connect_Results{Struct: r}}
return s.Connect(call)
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
})
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 4,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "authenticate",
},
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
call := TunnelServer_authenticate{c, opts, TunnelServer_authenticate_Params{Struct: p}, TunnelServer_authenticate_Results{Struct: r}}
return s.Authenticate(call)
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
})
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 5,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "reconnectTunnel",
},
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
call := TunnelServer_reconnectTunnel{c, opts, TunnelServer_reconnectTunnel_Params{Struct: p}, TunnelServer_reconnectTunnel_Results{Struct: r}}
return s.ReconnectTunnel(call)
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
})
return methods
}
// TunnelServer_registerTunnel holds the arguments for a server call to TunnelServer.registerTunnel.
type TunnelServer_registerTunnel struct {
Ctx context.Context
Options capnp.CallOptions
Params TunnelServer_registerTunnel_Params
Results TunnelServer_registerTunnel_Results
}
// TunnelServer_getServerInfo holds the arguments for a server call to TunnelServer.getServerInfo.
type TunnelServer_getServerInfo struct {
Ctx context.Context
Options capnp.CallOptions
Params TunnelServer_getServerInfo_Params
Results TunnelServer_getServerInfo_Results
}
// TunnelServer_unregisterTunnel holds the arguments for a server call to TunnelServer.unregisterTunnel.
type TunnelServer_unregisterTunnel struct {
Ctx context.Context
Options capnp.CallOptions
Params TunnelServer_unregisterTunnel_Params
Results TunnelServer_unregisterTunnel_Results
}
2019-03-18 23:14:47 +00:00
// TunnelServer_connect holds the arguments for a server call to TunnelServer.connect.
type TunnelServer_connect struct {
Ctx context.Context
Options capnp.CallOptions
Params TunnelServer_connect_Params
Results TunnelServer_connect_Results
}
// TunnelServer_authenticate holds the arguments for a server call to TunnelServer.authenticate.
type TunnelServer_authenticate struct {
Ctx context.Context
Options capnp.CallOptions
Params TunnelServer_authenticate_Params
Results TunnelServer_authenticate_Results
}
// TunnelServer_reconnectTunnel holds the arguments for a server call to TunnelServer.reconnectTunnel.
type TunnelServer_reconnectTunnel struct {
Ctx context.Context
Options capnp.CallOptions
Params TunnelServer_reconnectTunnel_Params
Results TunnelServer_reconnectTunnel_Results
}
type TunnelServer_registerTunnel_Params struct{ capnp.Struct }
// TunnelServer_registerTunnel_Params_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Params.
const TunnelServer_registerTunnel_Params_TypeID = 0xb70431c0dc014915
func NewTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return TunnelServer_registerTunnel_Params{st}, err
}
func NewRootTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return TunnelServer_registerTunnel_Params{st}, err
}
func ReadRootTunnelServer_registerTunnel_Params(msg *capnp.Message) (TunnelServer_registerTunnel_Params, error) {
root, err := msg.RootPtr()
return TunnelServer_registerTunnel_Params{root.Struct()}, err
}
func (s TunnelServer_registerTunnel_Params) String() string {
str, _ := text.Marshal(0xb70431c0dc014915, s.Struct)
return str
}
func (s TunnelServer_registerTunnel_Params) OriginCert() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return []byte(p.Data()), err
}
func (s TunnelServer_registerTunnel_Params) HasOriginCert() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_registerTunnel_Params) SetOriginCert(v []byte) error {
return s.Struct.SetData(0, v)
}
func (s TunnelServer_registerTunnel_Params) Hostname() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s TunnelServer_registerTunnel_Params) HasHostname() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s TunnelServer_registerTunnel_Params) HostnameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s TunnelServer_registerTunnel_Params) SetHostname(v string) error {
return s.Struct.SetText(1, v)
}
func (s TunnelServer_registerTunnel_Params) Options() (RegistrationOptions, error) {
p, err := s.Struct.Ptr(2)
return RegistrationOptions{Struct: p.Struct()}, err
}
func (s TunnelServer_registerTunnel_Params) HasOptions() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s TunnelServer_registerTunnel_Params) SetOptions(v RegistrationOptions) error {
return s.Struct.SetPtr(2, v.Struct.ToPtr())
}
// NewOptions sets the options field to a newly
// allocated RegistrationOptions struct, preferring placement in s's segment.
func (s TunnelServer_registerTunnel_Params) NewOptions() (RegistrationOptions, error) {
ss, err := NewRegistrationOptions(s.Struct.Segment())
if err != nil {
return RegistrationOptions{}, err
}
err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_registerTunnel_Params_List is a list of TunnelServer_registerTunnel_Params.
type TunnelServer_registerTunnel_Params_List struct{ capnp.List }
// NewTunnelServer_registerTunnel_Params creates a new list of TunnelServer_registerTunnel_Params.
func NewTunnelServer_registerTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Params_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
return TunnelServer_registerTunnel_Params_List{l}, err
}
func (s TunnelServer_registerTunnel_Params_List) At(i int) TunnelServer_registerTunnel_Params {
return TunnelServer_registerTunnel_Params{s.List.Struct(i)}
}
func (s TunnelServer_registerTunnel_Params_List) Set(i int, v TunnelServer_registerTunnel_Params) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_registerTunnel_Params_Promise is a wrapper for a TunnelServer_registerTunnel_Params promised by a client call.
type TunnelServer_registerTunnel_Params_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_registerTunnel_Params_Promise) Struct() (TunnelServer_registerTunnel_Params, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_registerTunnel_Params{s}, err
}
func (p TunnelServer_registerTunnel_Params_Promise) Options() RegistrationOptions_Promise {
return RegistrationOptions_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
}
type TunnelServer_registerTunnel_Results struct{ capnp.Struct }
// TunnelServer_registerTunnel_Results_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Results.
const TunnelServer_registerTunnel_Results_TypeID = 0xf2c122394f447e8e
func NewTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_registerTunnel_Results{st}, err
}
func NewRootTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_registerTunnel_Results{st}, err
}
func ReadRootTunnelServer_registerTunnel_Results(msg *capnp.Message) (TunnelServer_registerTunnel_Results, error) {
root, err := msg.RootPtr()
return TunnelServer_registerTunnel_Results{root.Struct()}, err
}
func (s TunnelServer_registerTunnel_Results) String() string {
str, _ := text.Marshal(0xf2c122394f447e8e, s.Struct)
return str
}
func (s TunnelServer_registerTunnel_Results) Result() (TunnelRegistration, error) {
p, err := s.Struct.Ptr(0)
return TunnelRegistration{Struct: p.Struct()}, err
}
func (s TunnelServer_registerTunnel_Results) HasResult() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_registerTunnel_Results) SetResult(v TunnelRegistration) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewResult sets the result field to a newly
// allocated TunnelRegistration struct, preferring placement in s's segment.
func (s TunnelServer_registerTunnel_Results) NewResult() (TunnelRegistration, error) {
ss, err := NewTunnelRegistration(s.Struct.Segment())
if err != nil {
return TunnelRegistration{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_registerTunnel_Results_List is a list of TunnelServer_registerTunnel_Results.
type TunnelServer_registerTunnel_Results_List struct{ capnp.List }
// NewTunnelServer_registerTunnel_Results creates a new list of TunnelServer_registerTunnel_Results.
func NewTunnelServer_registerTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Results_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return TunnelServer_registerTunnel_Results_List{l}, err
}
func (s TunnelServer_registerTunnel_Results_List) At(i int) TunnelServer_registerTunnel_Results {
return TunnelServer_registerTunnel_Results{s.List.Struct(i)}
}
func (s TunnelServer_registerTunnel_Results_List) Set(i int, v TunnelServer_registerTunnel_Results) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_registerTunnel_Results_Promise is a wrapper for a TunnelServer_registerTunnel_Results promised by a client call.
type TunnelServer_registerTunnel_Results_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_registerTunnel_Results_Promise) Struct() (TunnelServer_registerTunnel_Results, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_registerTunnel_Results{s}, err
}
func (p TunnelServer_registerTunnel_Results_Promise) Result() TunnelRegistration_Promise {
return TunnelRegistration_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type TunnelServer_getServerInfo_Params struct{ capnp.Struct }
// TunnelServer_getServerInfo_Params_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Params.
const TunnelServer_getServerInfo_Params_TypeID = 0xdc3ed6801961e502
func NewTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
return TunnelServer_getServerInfo_Params{st}, err
}
func NewRootTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
return TunnelServer_getServerInfo_Params{st}, err
}
func ReadRootTunnelServer_getServerInfo_Params(msg *capnp.Message) (TunnelServer_getServerInfo_Params, error) {
root, err := msg.RootPtr()
return TunnelServer_getServerInfo_Params{root.Struct()}, err
}
func (s TunnelServer_getServerInfo_Params) String() string {
str, _ := text.Marshal(0xdc3ed6801961e502, s.Struct)
return str
}
// TunnelServer_getServerInfo_Params_List is a list of TunnelServer_getServerInfo_Params.
type TunnelServer_getServerInfo_Params_List struct{ capnp.List }
// NewTunnelServer_getServerInfo_Params creates a new list of TunnelServer_getServerInfo_Params.
func NewTunnelServer_getServerInfo_Params_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Params_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
return TunnelServer_getServerInfo_Params_List{l}, err
}
func (s TunnelServer_getServerInfo_Params_List) At(i int) TunnelServer_getServerInfo_Params {
return TunnelServer_getServerInfo_Params{s.List.Struct(i)}
}
func (s TunnelServer_getServerInfo_Params_List) Set(i int, v TunnelServer_getServerInfo_Params) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_getServerInfo_Params_Promise is a wrapper for a TunnelServer_getServerInfo_Params promised by a client call.
type TunnelServer_getServerInfo_Params_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_getServerInfo_Params_Promise) Struct() (TunnelServer_getServerInfo_Params, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_getServerInfo_Params{s}, err
}
type TunnelServer_getServerInfo_Results struct{ capnp.Struct }
// TunnelServer_getServerInfo_Results_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Results.
const TunnelServer_getServerInfo_Results_TypeID = 0xe3e37d096a5b564e
func NewTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_getServerInfo_Results{st}, err
}
func NewRootTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_getServerInfo_Results{st}, err
}
func ReadRootTunnelServer_getServerInfo_Results(msg *capnp.Message) (TunnelServer_getServerInfo_Results, error) {
root, err := msg.RootPtr()
return TunnelServer_getServerInfo_Results{root.Struct()}, err
}
func (s TunnelServer_getServerInfo_Results) String() string {
str, _ := text.Marshal(0xe3e37d096a5b564e, s.Struct)
return str
}
func (s TunnelServer_getServerInfo_Results) Result() (ServerInfo, error) {
p, err := s.Struct.Ptr(0)
return ServerInfo{Struct: p.Struct()}, err
}
func (s TunnelServer_getServerInfo_Results) HasResult() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_getServerInfo_Results) SetResult(v ServerInfo) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewResult sets the result field to a newly
// allocated ServerInfo struct, preferring placement in s's segment.
func (s TunnelServer_getServerInfo_Results) NewResult() (ServerInfo, error) {
ss, err := NewServerInfo(s.Struct.Segment())
if err != nil {
return ServerInfo{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_getServerInfo_Results_List is a list of TunnelServer_getServerInfo_Results.
type TunnelServer_getServerInfo_Results_List struct{ capnp.List }
// NewTunnelServer_getServerInfo_Results creates a new list of TunnelServer_getServerInfo_Results.
func NewTunnelServer_getServerInfo_Results_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Results_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return TunnelServer_getServerInfo_Results_List{l}, err
}
func (s TunnelServer_getServerInfo_Results_List) At(i int) TunnelServer_getServerInfo_Results {
return TunnelServer_getServerInfo_Results{s.List.Struct(i)}
}
func (s TunnelServer_getServerInfo_Results_List) Set(i int, v TunnelServer_getServerInfo_Results) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_getServerInfo_Results_Promise is a wrapper for a TunnelServer_getServerInfo_Results promised by a client call.
type TunnelServer_getServerInfo_Results_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_getServerInfo_Results_Promise) Struct() (TunnelServer_getServerInfo_Results, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_getServerInfo_Results{s}, err
}
func (p TunnelServer_getServerInfo_Results_Promise) Result() ServerInfo_Promise {
return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type TunnelServer_unregisterTunnel_Params struct{ capnp.Struct }
// TunnelServer_unregisterTunnel_Params_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Params.
const TunnelServer_unregisterTunnel_Params_TypeID = 0x9b87b390babc2ccf
func NewTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
return TunnelServer_unregisterTunnel_Params{st}, err
}
func NewRootTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
return TunnelServer_unregisterTunnel_Params{st}, err
}
func ReadRootTunnelServer_unregisterTunnel_Params(msg *capnp.Message) (TunnelServer_unregisterTunnel_Params, error) {
root, err := msg.RootPtr()
return TunnelServer_unregisterTunnel_Params{root.Struct()}, err
}
func (s TunnelServer_unregisterTunnel_Params) String() string {
str, _ := text.Marshal(0x9b87b390babc2ccf, s.Struct)
return str
}
func (s TunnelServer_unregisterTunnel_Params) GracePeriodNanoSec() int64 {
return int64(s.Struct.Uint64(0))
}
func (s TunnelServer_unregisterTunnel_Params) SetGracePeriodNanoSec(v int64) {
s.Struct.SetUint64(0, uint64(v))
}
// TunnelServer_unregisterTunnel_Params_List is a list of TunnelServer_unregisterTunnel_Params.
type TunnelServer_unregisterTunnel_Params_List struct{ capnp.List }
// NewTunnelServer_unregisterTunnel_Params creates a new list of TunnelServer_unregisterTunnel_Params.
func NewTunnelServer_unregisterTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Params_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz)
return TunnelServer_unregisterTunnel_Params_List{l}, err
}
func (s TunnelServer_unregisterTunnel_Params_List) At(i int) TunnelServer_unregisterTunnel_Params {
return TunnelServer_unregisterTunnel_Params{s.List.Struct(i)}
}
func (s TunnelServer_unregisterTunnel_Params_List) Set(i int, v TunnelServer_unregisterTunnel_Params) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_unregisterTunnel_Params_Promise is a wrapper for a TunnelServer_unregisterTunnel_Params promised by a client call.
type TunnelServer_unregisterTunnel_Params_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_unregisterTunnel_Params_Promise) Struct() (TunnelServer_unregisterTunnel_Params, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_unregisterTunnel_Params{s}, err
}
type TunnelServer_unregisterTunnel_Results struct{ capnp.Struct }
// TunnelServer_unregisterTunnel_Results_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Results.
const TunnelServer_unregisterTunnel_Results_TypeID = 0xa29a916d4ebdd894
func NewTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
return TunnelServer_unregisterTunnel_Results{st}, err
}
func NewRootTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
return TunnelServer_unregisterTunnel_Results{st}, err
}
func ReadRootTunnelServer_unregisterTunnel_Results(msg *capnp.Message) (TunnelServer_unregisterTunnel_Results, error) {
root, err := msg.RootPtr()
return TunnelServer_unregisterTunnel_Results{root.Struct()}, err
}
func (s TunnelServer_unregisterTunnel_Results) String() string {
str, _ := text.Marshal(0xa29a916d4ebdd894, s.Struct)
return str
}
// TunnelServer_unregisterTunnel_Results_List is a list of TunnelServer_unregisterTunnel_Results.
type TunnelServer_unregisterTunnel_Results_List struct{ capnp.List }
// NewTunnelServer_unregisterTunnel_Results creates a new list of TunnelServer_unregisterTunnel_Results.
func NewTunnelServer_unregisterTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Results_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
return TunnelServer_unregisterTunnel_Results_List{l}, err
}
func (s TunnelServer_unregisterTunnel_Results_List) At(i int) TunnelServer_unregisterTunnel_Results {
return TunnelServer_unregisterTunnel_Results{s.List.Struct(i)}
}
func (s TunnelServer_unregisterTunnel_Results_List) Set(i int, v TunnelServer_unregisterTunnel_Results) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_unregisterTunnel_Results_Promise is a wrapper for a TunnelServer_unregisterTunnel_Results promised by a client call.
type TunnelServer_unregisterTunnel_Results_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_unregisterTunnel_Results_Promise) Struct() (TunnelServer_unregisterTunnel_Results, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_unregisterTunnel_Results{s}, err
}
2019-03-18 23:14:47 +00:00
type TunnelServer_connect_Params struct{ capnp.Struct }
// TunnelServer_connect_Params_TypeID is the unique identifier for the type TunnelServer_connect_Params.
const TunnelServer_connect_Params_TypeID = 0xa766b24d4fe5da35
2019-03-18 23:14:47 +00:00
func NewTunnelServer_connect_Params(s *capnp.Segment) (TunnelServer_connect_Params, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_connect_Params{st}, err
}
func NewRootTunnelServer_connect_Params(s *capnp.Segment) (TunnelServer_connect_Params, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_connect_Params{st}, err
}
func ReadRootTunnelServer_connect_Params(msg *capnp.Message) (TunnelServer_connect_Params, error) {
root, err := msg.RootPtr()
return TunnelServer_connect_Params{root.Struct()}, err
}
func (s TunnelServer_connect_Params) String() string {
str, _ := text.Marshal(0xa766b24d4fe5da35, s.Struct)
2019-03-18 23:14:47 +00:00
return str
}
func (s TunnelServer_connect_Params) Parameters() (CapnpConnectParameters, error) {
p, err := s.Struct.Ptr(0)
return CapnpConnectParameters{Struct: p.Struct()}, err
}
func (s TunnelServer_connect_Params) HasParameters() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_connect_Params) SetParameters(v CapnpConnectParameters) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewParameters sets the parameters field to a newly
// allocated CapnpConnectParameters struct, preferring placement in s's segment.
func (s TunnelServer_connect_Params) NewParameters() (CapnpConnectParameters, error) {
ss, err := NewCapnpConnectParameters(s.Struct.Segment())
if err != nil {
return CapnpConnectParameters{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_connect_Params_List is a list of TunnelServer_connect_Params.
type TunnelServer_connect_Params_List struct{ capnp.List }
// NewTunnelServer_connect_Params creates a new list of TunnelServer_connect_Params.
func NewTunnelServer_connect_Params_List(s *capnp.Segment, sz int32) (TunnelServer_connect_Params_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return TunnelServer_connect_Params_List{l}, err
}
func (s TunnelServer_connect_Params_List) At(i int) TunnelServer_connect_Params {
return TunnelServer_connect_Params{s.List.Struct(i)}
}
func (s TunnelServer_connect_Params_List) Set(i int, v TunnelServer_connect_Params) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_connect_Params_Promise is a wrapper for a TunnelServer_connect_Params promised by a client call.
type TunnelServer_connect_Params_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_connect_Params_Promise) Struct() (TunnelServer_connect_Params, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_connect_Params{s}, err
}
func (p TunnelServer_connect_Params_Promise) Parameters() CapnpConnectParameters_Promise {
return CapnpConnectParameters_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type TunnelServer_connect_Results struct{ capnp.Struct }
// TunnelServer_connect_Results_TypeID is the unique identifier for the type TunnelServer_connect_Results.
const TunnelServer_connect_Results_TypeID = 0xfeac5c8f4899ef7c
2019-03-18 23:14:47 +00:00
func NewTunnelServer_connect_Results(s *capnp.Segment) (TunnelServer_connect_Results, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_connect_Results{st}, err
}
func NewRootTunnelServer_connect_Results(s *capnp.Segment) (TunnelServer_connect_Results, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_connect_Results{st}, err
}
func ReadRootTunnelServer_connect_Results(msg *capnp.Message) (TunnelServer_connect_Results, error) {
root, err := msg.RootPtr()
return TunnelServer_connect_Results{root.Struct()}, err
}
func (s TunnelServer_connect_Results) String() string {
str, _ := text.Marshal(0xfeac5c8f4899ef7c, s.Struct)
2019-03-18 23:14:47 +00:00
return str
}
func (s TunnelServer_connect_Results) Result() (ConnectResult, error) {
p, err := s.Struct.Ptr(0)
return ConnectResult{Struct: p.Struct()}, err
}
func (s TunnelServer_connect_Results) HasResult() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_connect_Results) SetResult(v ConnectResult) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewResult sets the result field to a newly
// allocated ConnectResult struct, preferring placement in s's segment.
func (s TunnelServer_connect_Results) NewResult() (ConnectResult, error) {
ss, err := NewConnectResult(s.Struct.Segment())
if err != nil {
return ConnectResult{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_connect_Results_List is a list of TunnelServer_connect_Results.
type TunnelServer_connect_Results_List struct{ capnp.List }
// NewTunnelServer_connect_Results creates a new list of TunnelServer_connect_Results.
func NewTunnelServer_connect_Results_List(s *capnp.Segment, sz int32) (TunnelServer_connect_Results_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return TunnelServer_connect_Results_List{l}, err
}
func (s TunnelServer_connect_Results_List) At(i int) TunnelServer_connect_Results {
return TunnelServer_connect_Results{s.List.Struct(i)}
}
func (s TunnelServer_connect_Results_List) Set(i int, v TunnelServer_connect_Results) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_connect_Results_Promise is a wrapper for a TunnelServer_connect_Results promised by a client call.
type TunnelServer_connect_Results_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_connect_Results_Promise) Struct() (TunnelServer_connect_Results, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_connect_Results{s}, err
}
func (p TunnelServer_connect_Results_Promise) Result() ConnectResult_Promise {
return ConnectResult_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type TunnelServer_authenticate_Params struct{ capnp.Struct }
// TunnelServer_authenticate_Params_TypeID is the unique identifier for the type TunnelServer_authenticate_Params.
const TunnelServer_authenticate_Params_TypeID = 0x85c8cea1ab1894f3
func NewTunnelServer_authenticate_Params(s *capnp.Segment) (TunnelServer_authenticate_Params, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return TunnelServer_authenticate_Params{st}, err
}
func NewRootTunnelServer_authenticate_Params(s *capnp.Segment) (TunnelServer_authenticate_Params, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return TunnelServer_authenticate_Params{st}, err
}
func ReadRootTunnelServer_authenticate_Params(msg *capnp.Message) (TunnelServer_authenticate_Params, error) {
root, err := msg.RootPtr()
return TunnelServer_authenticate_Params{root.Struct()}, err
}
func (s TunnelServer_authenticate_Params) String() string {
str, _ := text.Marshal(0x85c8cea1ab1894f3, s.Struct)
return str
}
func (s TunnelServer_authenticate_Params) OriginCert() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return []byte(p.Data()), err
}
func (s TunnelServer_authenticate_Params) HasOriginCert() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_authenticate_Params) SetOriginCert(v []byte) error {
return s.Struct.SetData(0, v)
}
func (s TunnelServer_authenticate_Params) Hostname() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s TunnelServer_authenticate_Params) HasHostname() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s TunnelServer_authenticate_Params) HostnameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s TunnelServer_authenticate_Params) SetHostname(v string) error {
return s.Struct.SetText(1, v)
}
func (s TunnelServer_authenticate_Params) Options() (RegistrationOptions, error) {
p, err := s.Struct.Ptr(2)
return RegistrationOptions{Struct: p.Struct()}, err
}
func (s TunnelServer_authenticate_Params) HasOptions() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s TunnelServer_authenticate_Params) SetOptions(v RegistrationOptions) error {
return s.Struct.SetPtr(2, v.Struct.ToPtr())
}
// NewOptions sets the options field to a newly
// allocated RegistrationOptions struct, preferring placement in s's segment.
func (s TunnelServer_authenticate_Params) NewOptions() (RegistrationOptions, error) {
ss, err := NewRegistrationOptions(s.Struct.Segment())
if err != nil {
return RegistrationOptions{}, err
}
err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_authenticate_Params_List is a list of TunnelServer_authenticate_Params.
type TunnelServer_authenticate_Params_List struct{ capnp.List }
// NewTunnelServer_authenticate_Params creates a new list of TunnelServer_authenticate_Params.
func NewTunnelServer_authenticate_Params_List(s *capnp.Segment, sz int32) (TunnelServer_authenticate_Params_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
return TunnelServer_authenticate_Params_List{l}, err
}
func (s TunnelServer_authenticate_Params_List) At(i int) TunnelServer_authenticate_Params {
return TunnelServer_authenticate_Params{s.List.Struct(i)}
}
func (s TunnelServer_authenticate_Params_List) Set(i int, v TunnelServer_authenticate_Params) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_authenticate_Params_Promise is a wrapper for a TunnelServer_authenticate_Params promised by a client call.
type TunnelServer_authenticate_Params_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_authenticate_Params_Promise) Struct() (TunnelServer_authenticate_Params, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_authenticate_Params{s}, err
}
func (p TunnelServer_authenticate_Params_Promise) Options() RegistrationOptions_Promise {
return RegistrationOptions_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
}
type TunnelServer_authenticate_Results struct{ capnp.Struct }
// TunnelServer_authenticate_Results_TypeID is the unique identifier for the type TunnelServer_authenticate_Results.
const TunnelServer_authenticate_Results_TypeID = 0xfc5edf80e39c0796
func NewTunnelServer_authenticate_Results(s *capnp.Segment) (TunnelServer_authenticate_Results, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_authenticate_Results{st}, err
}
func NewRootTunnelServer_authenticate_Results(s *capnp.Segment) (TunnelServer_authenticate_Results, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_authenticate_Results{st}, err
}
func ReadRootTunnelServer_authenticate_Results(msg *capnp.Message) (TunnelServer_authenticate_Results, error) {
root, err := msg.RootPtr()
return TunnelServer_authenticate_Results{root.Struct()}, err
}
func (s TunnelServer_authenticate_Results) String() string {
str, _ := text.Marshal(0xfc5edf80e39c0796, s.Struct)
return str
}
func (s TunnelServer_authenticate_Results) Result() (AuthenticateResponse, error) {
p, err := s.Struct.Ptr(0)
return AuthenticateResponse{Struct: p.Struct()}, err
}
func (s TunnelServer_authenticate_Results) HasResult() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_authenticate_Results) SetResult(v AuthenticateResponse) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewResult sets the result field to a newly
// allocated AuthenticateResponse struct, preferring placement in s's segment.
func (s TunnelServer_authenticate_Results) NewResult() (AuthenticateResponse, error) {
ss, err := NewAuthenticateResponse(s.Struct.Segment())
if err != nil {
return AuthenticateResponse{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_authenticate_Results_List is a list of TunnelServer_authenticate_Results.
type TunnelServer_authenticate_Results_List struct{ capnp.List }
// NewTunnelServer_authenticate_Results creates a new list of TunnelServer_authenticate_Results.
func NewTunnelServer_authenticate_Results_List(s *capnp.Segment, sz int32) (TunnelServer_authenticate_Results_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return TunnelServer_authenticate_Results_List{l}, err
}
func (s TunnelServer_authenticate_Results_List) At(i int) TunnelServer_authenticate_Results {
return TunnelServer_authenticate_Results{s.List.Struct(i)}
}
func (s TunnelServer_authenticate_Results_List) Set(i int, v TunnelServer_authenticate_Results) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_authenticate_Results_Promise is a wrapper for a TunnelServer_authenticate_Results promised by a client call.
type TunnelServer_authenticate_Results_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_authenticate_Results_Promise) Struct() (TunnelServer_authenticate_Results, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_authenticate_Results{s}, err
}
func (p TunnelServer_authenticate_Results_Promise) Result() AuthenticateResponse_Promise {
return AuthenticateResponse_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type TunnelServer_reconnectTunnel_Params struct{ capnp.Struct }
// TunnelServer_reconnectTunnel_Params_TypeID is the unique identifier for the type TunnelServer_reconnectTunnel_Params.
const TunnelServer_reconnectTunnel_Params_TypeID = 0xa353a3556df74984
func NewTunnelServer_reconnectTunnel_Params(s *capnp.Segment) (TunnelServer_reconnectTunnel_Params, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 4})
return TunnelServer_reconnectTunnel_Params{st}, err
}
func NewRootTunnelServer_reconnectTunnel_Params(s *capnp.Segment) (TunnelServer_reconnectTunnel_Params, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 4})
return TunnelServer_reconnectTunnel_Params{st}, err
}
func ReadRootTunnelServer_reconnectTunnel_Params(msg *capnp.Message) (TunnelServer_reconnectTunnel_Params, error) {
root, err := msg.RootPtr()
return TunnelServer_reconnectTunnel_Params{root.Struct()}, err
}
func (s TunnelServer_reconnectTunnel_Params) String() string {
str, _ := text.Marshal(0xa353a3556df74984, s.Struct)
return str
}
func (s TunnelServer_reconnectTunnel_Params) Jwt() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return []byte(p.Data()), err
}
func (s TunnelServer_reconnectTunnel_Params) HasJwt() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_reconnectTunnel_Params) SetJwt(v []byte) error {
return s.Struct.SetData(0, v)
}
func (s TunnelServer_reconnectTunnel_Params) EventDigest() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return []byte(p.Data()), err
}
func (s TunnelServer_reconnectTunnel_Params) HasEventDigest() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s TunnelServer_reconnectTunnel_Params) SetEventDigest(v []byte) error {
return s.Struct.SetData(1, v)
}
func (s TunnelServer_reconnectTunnel_Params) Hostname() (string, error) {
p, err := s.Struct.Ptr(2)
return p.Text(), err
}
func (s TunnelServer_reconnectTunnel_Params) HasHostname() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s TunnelServer_reconnectTunnel_Params) HostnameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(2)
return p.TextBytes(), err
}
func (s TunnelServer_reconnectTunnel_Params) SetHostname(v string) error {
return s.Struct.SetText(2, v)
}
func (s TunnelServer_reconnectTunnel_Params) Options() (RegistrationOptions, error) {
p, err := s.Struct.Ptr(3)
return RegistrationOptions{Struct: p.Struct()}, err
}
func (s TunnelServer_reconnectTunnel_Params) HasOptions() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s TunnelServer_reconnectTunnel_Params) SetOptions(v RegistrationOptions) error {
return s.Struct.SetPtr(3, v.Struct.ToPtr())
}
// NewOptions sets the options field to a newly
// allocated RegistrationOptions struct, preferring placement in s's segment.
func (s TunnelServer_reconnectTunnel_Params) NewOptions() (RegistrationOptions, error) {
ss, err := NewRegistrationOptions(s.Struct.Segment())
if err != nil {
return RegistrationOptions{}, err
}
err = s.Struct.SetPtr(3, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_reconnectTunnel_Params_List is a list of TunnelServer_reconnectTunnel_Params.
type TunnelServer_reconnectTunnel_Params_List struct{ capnp.List }
// NewTunnelServer_reconnectTunnel_Params creates a new list of TunnelServer_reconnectTunnel_Params.
func NewTunnelServer_reconnectTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_reconnectTunnel_Params_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 4}, sz)
return TunnelServer_reconnectTunnel_Params_List{l}, err
}
func (s TunnelServer_reconnectTunnel_Params_List) At(i int) TunnelServer_reconnectTunnel_Params {
return TunnelServer_reconnectTunnel_Params{s.List.Struct(i)}
}
func (s TunnelServer_reconnectTunnel_Params_List) Set(i int, v TunnelServer_reconnectTunnel_Params) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_reconnectTunnel_Params_Promise is a wrapper for a TunnelServer_reconnectTunnel_Params promised by a client call.
type TunnelServer_reconnectTunnel_Params_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_reconnectTunnel_Params_Promise) Struct() (TunnelServer_reconnectTunnel_Params, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_reconnectTunnel_Params{s}, err
}
func (p TunnelServer_reconnectTunnel_Params_Promise) Options() RegistrationOptions_Promise {
return RegistrationOptions_Promise{Pipeline: p.Pipeline.GetPipeline(3)}
}
type TunnelServer_reconnectTunnel_Results struct{ capnp.Struct }
// TunnelServer_reconnectTunnel_Results_TypeID is the unique identifier for the type TunnelServer_reconnectTunnel_Results.
const TunnelServer_reconnectTunnel_Results_TypeID = 0xd4d18de97bb12de3
func NewTunnelServer_reconnectTunnel_Results(s *capnp.Segment) (TunnelServer_reconnectTunnel_Results, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_reconnectTunnel_Results{st}, err
}
func NewRootTunnelServer_reconnectTunnel_Results(s *capnp.Segment) (TunnelServer_reconnectTunnel_Results, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_reconnectTunnel_Results{st}, err
}
func ReadRootTunnelServer_reconnectTunnel_Results(msg *capnp.Message) (TunnelServer_reconnectTunnel_Results, error) {
root, err := msg.RootPtr()
return TunnelServer_reconnectTunnel_Results{root.Struct()}, err
}
func (s TunnelServer_reconnectTunnel_Results) String() string {
str, _ := text.Marshal(0xd4d18de97bb12de3, s.Struct)
return str
}
func (s TunnelServer_reconnectTunnel_Results) Result() (TunnelRegistration, error) {
p, err := s.Struct.Ptr(0)
return TunnelRegistration{Struct: p.Struct()}, err
}
func (s TunnelServer_reconnectTunnel_Results) HasResult() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_reconnectTunnel_Results) SetResult(v TunnelRegistration) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewResult sets the result field to a newly
// allocated TunnelRegistration struct, preferring placement in s's segment.
func (s TunnelServer_reconnectTunnel_Results) NewResult() (TunnelRegistration, error) {
ss, err := NewTunnelRegistration(s.Struct.Segment())
if err != nil {
return TunnelRegistration{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_reconnectTunnel_Results_List is a list of TunnelServer_reconnectTunnel_Results.
type TunnelServer_reconnectTunnel_Results_List struct{ capnp.List }
// NewTunnelServer_reconnectTunnel_Results creates a new list of TunnelServer_reconnectTunnel_Results.
func NewTunnelServer_reconnectTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_reconnectTunnel_Results_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return TunnelServer_reconnectTunnel_Results_List{l}, err
}
func (s TunnelServer_reconnectTunnel_Results_List) At(i int) TunnelServer_reconnectTunnel_Results {
return TunnelServer_reconnectTunnel_Results{s.List.Struct(i)}
}
func (s TunnelServer_reconnectTunnel_Results_List) Set(i int, v TunnelServer_reconnectTunnel_Results) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelServer_reconnectTunnel_Results_Promise is a wrapper for a TunnelServer_reconnectTunnel_Results promised by a client call.
type TunnelServer_reconnectTunnel_Results_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_reconnectTunnel_Results_Promise) Struct() (TunnelServer_reconnectTunnel_Results, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_reconnectTunnel_Results{s}, err
}
func (p TunnelServer_reconnectTunnel_Results_Promise) Result() TunnelRegistration_Promise {
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)
}
// 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)
}
// 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{\x90Tev?\xe7\xde\x1e\xee\x0c\xcc" +
"\xd0}s\xdbr\xa0\x18:\xa0Da\x85\x88\xb3$\xee" +
"$\xd9\x9e\x07\xc3\xce\xb0<\xe6N\xcf\xa0\x8e$\xe5\x9d" +
"\xeeof\xee\xd0}os\x1f\xc0\x10X\x1e\x85Q&" +
"\xa0\xe8J\x0a\\\xdcR\\\xe3#&+.VV\x03" +
"\x96&\x9b\xa8Y\x89\xeb\x06R\xb2\xd1\x0a\x0aVJK" +
"\xcb\xc5G\x19R\xeaM\x9d\xfb\x9ef\x18\xc0$U\xfb" +
"\x0ft\x9d{\xbe\xc7y\xfd\xce\xe3\x9b\xeb\xef\x9a\xdc\xcc" +
"-\xac\xba&\x09 ?U5\xc9a\xf3~\xb9\xf1\xc1" +
"9\xff\xb0\x1d\xe4\xe9\x88\xce\xf7\x8e,M\x9f\xb3\xb6\xff" +
";T\xf1\x02@\xe3\x88\xb0\x11\xa5\xdd\x82\x00 \xed\x14" +
"\xfe\x13\xd0\xa9\xfa\x9d\x13\xa7\xca\xa7\x84\x1d N\x8f3" +
"s\xc4\\\xaa^\x8a\xd2\xb6jb\xde\\\xbd\x1e\xd0\xf9" +
"\xc3\xd2k\x07\x7fo\xef\xcf\x89\x99\x8b\x98\x01\x1b\xdf\xad" +
"\xde\x88\xd29\x97\xf3\xb3\xea\x95\x80\xce'\xf7\xd5\xff\xd5" +
"C\xff\xf2\xf2\xed ^\x83\xe0\x9f]W\xf3+\x04\x94" +
"f\xd5\xfc\x18\xd0\xf9\xd7\xeb7\x9d\xb9\xed\x93{\xee\x1c" +
"{n\x82\xf8^\xac\x19E\xe9d\x8d\x00\xbc\xf3\xc0\xad" +
"\xe9\x7f\xc6\x07?\xbf\x07\xc4ki\x1b\xa4\xcf\xcf\xd4L" +
"\xe6\x00\xa5c5Y@\xe7\xb5\xeb\x8e<\xb7\xe7'w" +
"\xfc\x00\xe4k\x10\xc1[\xffa\xcd\x7f\xd398\x99\x18" +
"\xce\xfe\xe8\x1b\x89\xbf~\xed\xb7~\xe828\x8f\xbc~" +
"\xd3\xd3{~\xf2\xdb\xefC/'`\x02\xa0q\xeed" +
"\x83x\x17M&]\xdc\xf7\xc6\xd1\x15\xa5{\xee?\xe8" +
"]\xda\xdd\xeb\x8a)\x1c\x07\x09gG\xe7\xe7\xa5\xde\x87" +
"s\x0f\xfb\xe2\xb8\x9fj\xa6|LK\x1b\xa6\xd0\xd2E" +
"\xbfzw\xe5\xf2\xa7\x07\x1e\xf5\x19\xdc\x8b\x9e\x9b\xf24" +
"1\xd4\xd4\xd2=^^\x9f\xda\xd5\xf2\xfbw?Zi" +
"\x95*\xe2\x9c_;\x8aR{-\xfdl\xa9\xbd\x09\x01" +
"\x9d\xd1o\x1d]\xf5\xc9\x9f\x99O\x80<\x1f\x13\xce\xcf" +
"v\x9e^7\xf7\xf1\x81\x97\xdck\xf3\x00\x8d\xcf\xd6\xfd" +
"\x92\xb6>VG\xaa\xac\xfb\xbby+\xee>\xb3\xec\x10" +
"m\x1d3\x8bw\x89\xd2\xd4&\x946O%\xcb\x8cL" +
"%\xee_\\\xb7\xea\xf9\xe7\x9f\x1a<Ty\x11\xd7\xe2" +
"\xd3\x92KQ\x9a\x9f$\xee\xb9I\xe2\xbe\xa2\x13\xdf|" +
"aa\xe2o\xe3v|+\xf9>\x1d~\xd6e\xb8\xf5" +
"\x8bg\xfe\xbe\xfd\xa3\xe3\xcf\xc6-tO\x8a#\x0b=" +
"\x92\"\xc1\xfbF\xb1\xf4fS\xf3\xf3 _\x8b\xe8\x0c" +
"\xef\xdddu\xec\xdb\xed@/\x0a\xc8\x014\x1eKm" +
"\xa4\xcdN\xa6\xc8\xbf\x1a>l\xad\xd3>\xda\xfeB\x85" +
"3\xba\xa7.\x12\x97\xa2\xd4)\xd2\xd5\xda\xc5\x1f\x03~" +
"\xfe\xc4\x1d{:O/~I\x9e\x8e\x89J\xa1\xdf\x16" +
"7\xa2\xf4\x19\xf16\x9e\x153\xa4\xcfP\x83\x15\xec\xae" +
"\xd4\xb3\xa4a\x94\x16I\xf4s\xa1\xe4\xb2/\xbd\xf5\xfb" +
"\xf7V\xbd\xfb\xfd\x97*UJ\x1e\xde\xf8Gi\x03%" +
"9M?\x97\xa7\xaf\xe4\x01\x9d\xe9O\xfd\xc1\xdf\xb4\x16" +
"N\xfe|\x9c \x92\x8e]\xf9\xb1t\xf2J\xfau\xe2" +
"J\x92\xf1\xf4\xfcC\x7f\xfa\xde\xee\xd7\x8f\xc7=ea" +
"\xbd\xeb\xb1\xed\xf5\xa4\xb0;\xbe1\xb2q\xc5\x9c\xd1\x13" +
"\x95\x06r9Y\xfd(J\x9b\xeb]s\xd6\xd3v\xdc" +
"\xbb\xca\xb4\xad\xff\xf6\xed7c>\xfb^\xfd;\x08\x09" +
"g\xc5\xaa[\x87k6\x9f>\x1d?\xe8\xadz\xcft" +
"\xeeA\x87\xc5{\xa5#\x0f\xfd\xe5\x19:H\xa8T\xb7" +
"8\xad\x0f\xa59\xd3\\\xf5L{\x94\x83X\xec\x8c\xe7" +
"8\x0d3\x9aP\x9a?\xc3u\x9c\x19t\xafE\xb7\xb5" +
"\xb0\xd57\xde\xfc>\x88\xd3\xf91P\xa1\x12\xe7\x08q" +
"6\xda3\xee@is\x83\x00\xe0\xdc5\xd8\xf7\xca\xd9" +
"\xb6\x87~]\xb9\xb9+\x10khB\xc9&\xbe\xc6\xb5" +
"\x0d\xae}\x1a\x17\xfe\xf9\x87{\x1fn;{\xde\xeeG" +
"g\xb6\xa2tl&\xdd\xe3\x95\x99\xdf\x91\xce\xcdt7" +
"\xff\xde\xe2\x95\xdf\x9a\xfd\xe2\xc7qM\xbc=\xd3\x8d\xde" +
"\xcff\x92&\x06n\xfc\xe0;s\xee\xfa\xa7\x8f+\xec" +
"\xe72^\x91\x99\x87\xd2\x9c\x0c\xed8+\x93\x05\xfch" +
"\xc9\x0f\x8fOON\xfft\xbc8n\xcf\x0c\xa3t\x0b" +
"\xf16\xf6f\xee\xa6\x8b\xde\xfc\xce\xfd\xeb\xb3?\xf8\xf4" +
"s\x92\x8b\xaf\xc0\xb9\x9aY}(5\xcc\xa2\x9d\xa7\xcd" +
"\xa2XZ\xf6\xe4\xc9o\x0f\xed}\xf9\xdc\xb8\xc8\xfd\x8f" +
"\xb3\xb6\xa3t\xd2\xe5>1\x8b \xe7/\x84\x03\xa7\xb7" +
"\xfe\xc7\x9f|\x11\x97\xea\xe8\xecwH\xaa\xd7g\x93T" +
"\x9b>\xda\xdfq\xf7\xea'\xbf\x8a3\x9c\x9d\xfd\x9c\x8b" +
"\x8dW\x11C\x18\x8c\xe3y\xda\xac\xabZQZx\x15" +
"\x9d7\xff\xaa,\xccw,[\xd3X\xd1('\xf2\xbf" +
"\x1b\xfc\xcc/\xc8+e\xad\xdc\xd4b[CL\xb3\xd4" +
"\xbcb\xb1n\x965\xcb\xbaf\xb2.D9\xc5'\x00" +
"\x12\x08 *\xc3\x00\xf2m<\xcaE\x0eE\xc44\xa1" +
"\xb5\xa8\x12q\x88G\xd9\xe2P\xe4\xb84!\x82\xb8v" +
"6\x80\\\xe4Q\xde\xc0!\xf2i\xc2;\xd1\xbe\x17@" +
"\xde\xc0\xa3\xbc\x83C\xa7\xcc\x8c\x92\xa21\x0d\x92V\xbb" +
"a`-pX\x0b\xe8\x18\xcc2F\x94\xfe\"$Y" +
"\x8c,\x0c\xaf\xb7\xb0\x0e8\xac\x03t\x86t\xdb0{" +
"5\x0b\xd5b7\x1b0\x98\x89C8\x098\x9c\x048" +
"\x91xm\xba\xa6\xb1\xbc\x95\xb3\xf3yf\x9a\x00$Y" +
"u(\xd9\xdc\xfb\x01\xe4\xebx\x94o\x8cI\xb6\x88$" +
"\xfb&\x8fr3\x87\x8e\xc9\x8cu\xccX\xa6c^\xb1" +
"T][\xa1\xf0%\x16^;_T\x99f\xb5\xe9\x90" +
"\xd4\x06\xd4ALE\xa1\x00\x88\xa9\x89/\xd6\xbeA5" +
"-U\x1b\xecq\xe9\xd9.\xbd\xa8\xe6G\xe8v\xb5\xae" +
"&\x1b\x9ah\x0f\xf1\x8a>\x00\xe4D\xb1\x15 \xab\x0e" +
"j\xba\xc1\x9c\x82j\xe6I(\xe0\xf3\xd6\x96~\xa5\xa8" +
"hy\x16\x1e4\xe9\xfc\x83\xbc\x03r\xae\x1c\x0b\x94\x98" +
"\xb5\xaf\xeeR\x0c\x85/\x99rm\xa8\x8f\xf6>\x00y" +
"1\x8frWL\x1f\xcb\x97\x02\xc8\xcbx\x94o\x8eY" +
"\xba\xb7\x15@\xee\xe2Q^\xcd\xa1\xa3\x1b\xea\xa0\xaa\xb5" +
"1\xe0\x8d\xb8\xc1LKSJ\x0c\x00\x02\x85m\xd1\xcb" +
"\xa4D\x13S\x11JWh\xaa\xea|\x01:X\xb1\xa8" +
"\xdf\xa4\x1b\xc5\xc2J\xef\x1c\x9d\xb4\xed\x9a2\\&\x8c" +
"cy\xd78$\xb7\x9ag\x0bl\x93y\xebl\xc35" +
"\xe4\xd5\xdd\xcc\xb4\x8b\x96\x09 'B\xf1\xeb\x9a\x00\xe4" +
"j\x1e\xe54\x87Y\xc3e\xc0T\x04\xea\x15W\xbd\x98" +
"\xaem\xcd`\x83\xaai1\xc3#_\x9d%\x85\x97\xcc" +
"\xf8\x81\xe4\x7f)\x1e\xe5\x19\x1c:\x83\x86\x92g]\xcc" +
"@U/\xacP4=\xc7\xb3<V\x01\x87U\x13{" +
"\xd2\x12E-\xb2\x82'\xdd\x82|\xc6\xfd\x9f\xa2\xb7\xd6" +
"q\xbc\xf0\xed\x8b\xc2\xb7\x0e\xbfr\xfc\xf8\xdd\x18\xc5o" +
"\x1d\xf7\xa5s~\x00\xd7\xf1_8~\x08SDX<" +
"\xca[)\"\xec2\xe9\xd4\x04^70\x15\xa1\xa4\xaf" +
"\x1dV\x18$Mk\x90eyR4\xa6\x82l\xef1" +
"\x08\x05}\x08SQ)\xe3/3\xd8:f\x98\xac\x0b" +
"\x92\x86\xbea\x04SQ\xd6\xaf\xd0\xfa\xd4\xcb\xd5z`" +
"\xe8p\xd5\xc4\xeb\x0d\x96\xf7 \xc3_\xde\x95\xf1\x8c\x16" +
"\x83C\xd2\xd1j\x1e\xe5\xa1X\x90\xb0~\x00\xb9\xc0\xa3" +
"\\\x8e\x05Iii\xa4M\x91\x0f\xf0\x90\"\xa7\xcc\xa3" +
"\xbc\x89\x1b\x8bpl\x1d\xd3\xac\xc5\xea \x08\xcc\xfc\x7f" +
"\x08\xa31R\xfa2\x86\xd2\xc5\\\x92\xbc\xa5\x96G\xb9" +
"\x9e\xe0\x9a\xbe2\x8b\x02\x9bN\x0b\x0b\xe1\x8b\x9f\xd6F" +
"\xff\xfa\xe0\xdb\xe5\xefb\xf8\xf8[\x1f\x1e\xb6\x9f\x0e\xdb" +
"\xc7\xa3\xfc\xa3\x98*\x1f2\x00\xe4\x07y\x94\x9f\xe4\x10" +
"}M>~\x10@~\x92G\xf9\xa7\xa4I\xce\xd3\xe4" +
"3\xf3\xa8m\xe2Q~\x95C1\xc1\xa7\xa9+\x10_" +
"\xa1\x90z\x95G\xf9\x0d\x0e\xc5\xaaD\x1a\xab\x00\xc4\x13" +
"d\x9d\xe3<\xca\xa7.\x84V\xf9\xa2n\x17\x06\x8a\x0a" +
"d\x0cV\xe8\\\x1c\xd25\xbb\xd4e\xb0u*\xea\xb6" +
"\xd9bY\xac$\x94-3H<IK\x194q*" +
"`\x17\x8f\x98\x8aJI@\"\x86{\xa2\xc1\x0a\xab\x98" +
"a\xaa\xbc\xae\x85\xb9C\xd5,\xa6Y\xcb\x14\x10\xfaY" +
"1\xa4N\x80-\xdd~\x84P|\xf8\xc1\xaeGx\x88" +
"\x83\x04\xe33\x1c\xc7Wb;\xe9\xa6\x99Gy\x19\x87" +
"\x0d\xf8\x15\x91I\x8f\x9d\xdd\x00r\x07\x8fr\x0f\x87\x0d" +
"\xdc\x97D&M\xca}\x11\x9a'\x87,\xab\x8c\xa9\xa8" +
"\xc4\xf4\x8d\xbd\x9e\xf5\x9bz~\x0d\x03$P\x0c\xeb\x1d" +
"\xff\xeb\x90\x0f\xd2\xc0\x17\x0b\x98\x8aZ\xc4\x0aO\xe1/" +
"\x94\xa1\xb3T\x0f\xe8\x86\x9b\x00\xa3ttC$D\xe0" +
"\x1d\x9d}\x91\x04\"\xd7\xec\x89%\xf7G\xf7\xcf\xe4\x15" +
"\xdbdcK\x8b\x96\x01\x0bxf\x84hj\x0e\xe9v" +
"\xb1\xd0\xcd@\xb0\x8c\x11D\xe0\x10'\xc6\xd8\xc5zG" +
"L\xf1\x9e\x1b\x8f\x9f6\xc3\xac\xd9\x17\xcf\x9a\xbe\xfa{" +
"I\xfd=\x1eJ8EB)\xadC\x07\xde\xb4\xc2\xeb" +
"z\xc4.\xdduN\x018\x14\x00\x1d\xbblZ\x06S" +
"J\x80\xa1\xb7\x11\xff\xd4\xcbHF\x15\xa0\xd8\xa5$\xdd" +
"\xb8\xffMJ\xfd\x97\x9f\xc3\xbd|:&\x83\x1f\x8c%" +
"\xd4\xbc\xbf\x1a\xdd\xe5m\xba&\\v\x95\xe6#\x98\x97" +
"C\x16\xf85\x01\x15\x90Ar\x9dK\xc9\xe0j\x1e\xe5" +
"\xeb\xe3\xc9u>\xa9\xe8Z\x1e\xe5or(0\x83\xf2" +
"d\xd8\xe9{\x87n1\xbd\x8a\x14S\xd1\x18\xe7\xe2\xd7" +
"\x89\x15\xeb\xaa\xae\x9d\xe7\x86\xb3\xa3p\x09M\xd8yC" +
"\xcc\xae\x81\x09\x97\xf7Gv\x15\xd6\xb0\x91\xc0J\x19V" +
"R\xd4\x08\x8d|\xe3\xb6\x80\xf0\xdd\x88g\xc2\xa2\xd6O" +
"\xfe^\xea\xcfz\xd6\xa2K\xa6\xc3Kn\x1e\x05\x90\xb7" +
"\xf2(\xef\x8a]r'\xf5\x08\xbbx\x94\xf7\xc5.\xb9" +
"\x97\x94\xb8\x87G\xf9@,{\xee'\x03\x1f\xe0Q~" +
"\x8cCLx\x90\xff\x08A\xfec<\xca\x879\x17\xb0" +
";Z\xdat\x0d\xfdK\x98\x00a\x9f0\xc4\x14\xc3\xea" +
"g\x0aZ\x9d\x9a\xc5\x8cu\x0a\x16\x03H\xd8b\xa9%" +
"\xa6\xdbV\x08\x11%e\x83[Xa\xa1\xc3[%(" +
"\x96\x895\xc0a\x0dE\xa4\xc9\x8c6\x83\x15\x90\xac\xa1" +
"\x14\xbb\x14\xde\x1a\xba\x14\x05\x8d\x05\xf1\xe48\xea\xa1\xb2" +
"l\x13\x8f\xf2\x9d\x04%\x18\x9b&\x89\xb7\x0f\x03\xe7\"" +
"\x09\xc9\xbc\xb65^Zp^\x9a\x8b\xb7ZnB\x9c" +
"\x04 n#\xed\xec\xe0Q\xde\xc3\x05W\xeb\xd0!\xeb" +
"Eh\xa5\xa9\xfdVf\x0b\xa1\xa6\xca\"y\xfdzA" +
"E]\xebq\x15\x85\x91\xa6\xf2z\xa9l\x90+\xab\xba" +
"&\xdbJQ\xe5\xad\x91p\xe1\x84\xba H\xf2By" +
"e9\xe3\x1a\x8b\x94qc\xa0\x0ci\x04\x97\x02\xe46" +
" \x8f\xb9\x1d\x18\xb9\x8b\xb4\x0d[\x01r\x9b\x88~'" +
"F\x1e#\xdd\x8e\xd3\x01r[\x89\xbe\x0b\xc3\x0eT\xda" +
"\x89O\x00\xe4v\x11y\x1fF\xa5\x82\xb4\xd7\xdd\xfe>" +
"\xa2?\x88Q\xb5 =\x80\xf3\x00r\xfb\x88~\x98\xe8" +
"\x938W\x93\xd2!\x1c\x06\xc8=E\xf4#D\x17\xaa" +
"\xd2\xd4nK\xcf\xa2\x01\x90\xfb)\xd1\x7fF\xf4\xea\xfa" +
"4V\x03H/\xba\xf4\x17\x88\xfe*\xd1k\xa6\xa5\xb1" +
"\x06@z\x05\xb7\x03\xe4^&\xfaq\xa2O\xc64N" +
"\x06\x90^\xc7\xfb\x01r\xc7\x89~\x8a\xe8S&\xa5q" +
"\x0a\x80\xf4\x96{\x9f7\x88~\x86\xe8\xb5\x894\xd6\x02" +
"Ho\xe3A\x80\xdc\x19\xa2\xff\x9a\xe8uB\x1a\xeb\x00" +
"\xa4\x0f]\xb9> z5\x17\xe2`g!\x0e\xc7\xe4" +
"\x86jT\x8e\xf0\xba\x19\xba\x02\xf3;S\xf4rE\x97" +
"\x9e\xa4\xd6\x14\x93\xd1\x08\x19\x10\x93\x80NY\xd7\x8b+" +
"\xc6\xc2\xfc\xc5*\"\xdf\x8d \xa9k\x9d\x850.=" +
"\xe7[\xa6C&\xaf\x14;\xcbQ\x8dd\xb6\xd8\x96n" +
"\x97!SP,V\x08\x13\xb5akK\x0c\xbd\xd4\x83" +
"\xcc(\xa9\x9aR\x84\xf0\xcbD\xbe\x98\xb4m\xb5\x10\xee" +
"=aa\xe7\x0c0\xc5\xb2\x0df\x92h\x17\xc8\xb8\\" +
"\xa5Gg\xcaM=\xca`\xc5\x80a^\x94\x1eB\xb4" +
"\x9b\x7fC\x94\x1d\x92\xf1(\xcc\xacS\x8a6\xbb\x94b" +
"p\xc2\x96\xa5;\xeb\xb5<\x17\xebl\x83q\xd8\xc5\xab" +
"\xf9\xde\x8a\xcc\xeb\xe5\xc3\xf3\xa6)\xad\x91\xb0\xa1\xac\x86" +
"?a\xe9\xe0\xa2\x9c\x17Xk\xc0\xef\\!C{\xc7" +
"\xfc&\x9cW\xfa~s\xa9\x9a\x18d\x96\xf7\xabS\x1b" +
"\xd0\xa9<\x10\x94\x92\xf95Ww33y)Z\x8c" +
"&\x90\x17\xcf\xdf\x1d==]\xd1\x10\x83\xf7\xc0\xff\xfa" +
"\x10\xefZ\xb0\x1b \xd7L\x81\xbb\x0cC\x1dJ\x9d." +
"\xeet\x10\xb9\x07\xa3\xaaW\x92]|\xe9\"\xfaj\x8c" +
"\xfa\"\xe9\x16\x17\x17V\x13}\xc8\xc5\xbb\x16\x0f\xef\x98" +
"\xbb}\x81\xe8e\x17\xef\xd0\xc3\xbb\x92\xbb\x7f\x91\xe8\x1b" +
"\xe2xg\xe3\xe8\x18\xf8\x15x\x0f\xef\xb6\xb98\xb5\x83" +
"\xe8{\\\xbcKxx\xb7\x1b\x9f\x06\xc8\xed!\xfa\x01" +
"\x17\xef\xaa<\xbc\xdb\x8f\xcf\x01\xe4\x0e\x10\xfd1\x17\xef" +
"&yx\xf7\x88\xcb\xffX\x88\xb3SZ=\xbc;\xe4" +
"\xe2c\x88\xb3\x8em\x14s\x96\xa1j\x80\x83Ql\xe4" +
"\xcb\xdfe\xac\xdc\x02\xc9\xa2\xba\x8e\x85\xb9\xa8\xa0*\xc5" +
"\xc5\xb6R\x84L\xceR\xf2k\xa2\xd2\xbehv(Z" +
"\xc1\xc4!e\x0d\xa3\x0c&\xc4s\xbdU4W1C" +
"\x1d\x00\x8c\x9a\x81\xb0\xf6Iv\xe9zeI\xe4\xd6\x94" +
"\xcc\xf0\xc0/\xfcVR6t\x16\x8a\xac\x0d\x83\x0a\x88" +
"\xd7\xa2\x0c\xaa\xd2\x17]\xd3\xd0+Kz\xd4\xcc\xd8z" +
"\xa3\xec\xb7\x17A\xdd\xd2\x93\xad(H\xd8\x862\xcb[" +
"m:j\x96\xaa\xd9\xec\xbc\x0d\xf2C\xb6\xb6\x86\x15\xda" +
"Q\xcb\xeb\x05U\x1b\x84\xf3\xfa\x1a\xfeB\xb3\xa3X\xa1" +
"\xe6F3\xc6\xde\xde\xc4\xb9M\xc0\xb9\xd0Ee\x87\xd8" +
"\x14M\x07\xb2ywU\xd6`\x8a\x19kl'8\xcd" +
"\x9fuzA\xe6M\x02\xaa\x00\xc2\x87*\x0c\x86\xfd\xe2" +
"\xa1\x8d\xc0\x89\x8f\x0b\x18\xbd\x91`\xf0$\">`\x00" +
"'\xee\x15\x90\x0b\x1f\x101x\xfc\x13w\x8e\x02'\xde" +
". \x1f>\xeaa0I\x17GZ\x81\x13K\x02&" +
"\xc2\x07N\x0c\xc6\xf0\xa2B\xa5\xd5-\x02V\x85\xaf\x85" +
"\x18\xbc\xf5\x88\xcb\xb7\x03'\xb6\x0bN\xd0AA\xd6\x13" +
"\xa3\x19\x9d\x000 \xe3BF3:\xc1\xf4\x09\x83N" +
"\x0b\xa0\x19\xb7\xf8\xf0\xdc\x8cN0\x7f\x85d^\xb1X" +
"3\xb5\xa7\xdeG\xf4\xc1\x1b\x9a1>\xd7\xe4/\xd4\x13" +
"\x8d_[\xb7F\xf5_\x00\xc0\xdbF\xa3\xf2/\xecC" +
"w?\x11/\xad\xfdq\xca\xfe\xed\xfe0\xe6pl\x9c" +
"r\x88\xea\xed\xc3<\xca\xbf\xe0\xa2\xa2!\xf0\xe9`\x14" +
"\x88\xba\x114\xc6\x13L\x04}\xcf\xf7\xcb\xde\xca\xb9\xa0" +
"S\xd0\x87\xdc\xb2\x18\xbd\xadL\x88\xd2A|X85" +
"6,\xc4\xa0%\x17\xc6d\x8f\xf8\xe8p\xeaE\xfa\xbb" +
"x\x83\xe9\xa6\xb3\x84\xeb\x92\xc1\xd3(\x06\xaf\xd8\xa2H" +
"\xaeU'8A\x13\x8aA.\x84\x0a\x93]f'\xde" +
"\xcd2\xff\x9bd=\x8e\x83x\xe7$\xc9#=\x81\xc2" +
"}\x87c\xa3\xbd\xa2\xee7\x91\xc9\x15\xf1>`\x02]" +
"y\x17\x0e\xaa\xf6$-\xa6\xfdg\x84\xfb?3\xdb\x9f" +
"\xc7\x1d\x89\x15;\xcf\xce\xf6\x1d\xe8\x85Xkwt)" +
"\x80|\xc4\x1b\xd2\x05\xefD'\xc8Q\xdf\xe0Q>\x13" +
"s\xbf\xb7\x89\xf1\x14\x8f\xf2\x07Q\xbe\x12\xdf\xa36\xe7" +
"\x03\x1e\xe5\xff\xa2d\x95\xf0\xda\x9c\xcf\xa8\xa5\xfd\x94\xc7" +
"n\xf4[\xee\xe0\x11\xc96\"\xf4.\xea\x83\xcbTm" +
"\xdc\xb2.x\x99B\x8b0\xd16\x08\xd8\xc7\x02h\xe7" +
"\xe2X\xa1\x1b\xce\x95\x90\x199\x8a\xe1\x02\x9a\xe1\xbcf" +
"\xfcI\xee\x04\xaa\xcd\xf9\x81\xe4\xc5\x91_\x17\xc4\x1a\xfb" +
"\x83\xb1\x99W\xa0X\xf99\x7f\x96t[L\xb1\x7f\xdc" +
"\x1f\xcd\xa6\x09l\xf4\xderAA\x8b-1\xd8Z\x9b" +
"\x09Z~$jp\xa9\xc5\xcb\x9b\xbdX\xa6\xe2z\x89" +
"\xc1\xb2km\x16g\x08\xde#@P\xf5\xc2y\x0f\x11" +
"\xe3T\x897\xb1\xfe\x9c\x9e_\xc3\xac1\xef4\x15o" +
"\x89\xdd\xd1cD\xf8\x94\xd8\x1d\x7fJ\xf4!j\xedp" +
"4&\x0f!jd4\xea\x8e\xc7/\x0b\xfeo2\xf9" +
"\xd7zN\xa3\xa2X\xb8\x94\x821\xfc+\x9f\xaf9\xb4" +
"\xbf\xd4\xfa>z$\xbe\xccA\x17\x84\xb8\x81\xb1?\x02" +
"\xa1C8\x7f\xf3\xff\x09\x00\x00\xff\xff\xa6\xa4\xec\x8a"
func init() {
schemas.Register(schema_db8274f9144abc7e,
0x82c325a07ad22a65,
0x8407e070e0d52605,
0x84cb9536a2cf6d3c,
0x85c8cea1ab1894f3,
0x8891f360e47c30d3,
0x91f7a001ca145b9d,
0x9b87b390babc2ccf,
0x9e12cfad042ba4f1,
0xa29a916d4ebdd894,
0xa353a3556df74984,
2019-03-18 23:14:47 +00:00
0xa766b24d4fe5da35,
0xa78f37418c1077c8,
0xaa7386f356bd398a,
2019-03-18 23:14:47 +00:00
0xb14ce48f4e2abb0d,
0xb167b0bebe562cd0,
0xb70431c0dc014915,
0xb9d4ef45c2b5fc5b,
0xbe403adc6d018a5a,
0xc082ef6e0d42ed1d,
0xc744e349009087aa,
0xc766a92976e389c4,
0xc793e50592935b4a,
0xcbd96442ae3bb01a,
0xd4d18de97bb12de3,
0xd58a254e7a792b87,
0xdc3ed6801961e502,
0xe3e37d096a5b564e,
0xe4a6a1bc139211b4,
0xea20b390b257d1a5,
0xea58385c65416035,
0xf0a143f1c95a678e,
0xf143a395ed8b3133,
0xf2c122394f447e8e,
0xf2c68e2547ec3866,
2019-03-18 23:14:47 +00:00
0xf41a0f001ad49e46,
0xf7f49b3f779ae258,
0xf9c895683ed9ac4c,
0xfc5edf80e39c0796,
2019-03-18 23:14:47 +00:00
0xfeac5c8f4899ef7c,
0xff8d9848747c956a)
}