curben
/
cloudflared-mirror
mirror of https://github.com/cloudflare/cloudflared.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
cloudflared-mirror/tunnelrpc/tunnelrpc.capnp.go

3939 lines
128 KiB
Go
Raw Blame 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) }
func (s Authentication_List) String() string {
str, _ := text.MarshalList(0xc082ef6e0d42ed1d, s.List)
return str
}
// Authentication_Promise is a wrapper for a Authentication promised by a client call.
type Authentication_Promise struct{ *capnp.Pipeline }
func (p Authentication_Promise) Struct() (Authentication, error) {
s, err := p.Pipeline.Struct()
return Authentication{s}, err
}
type TunnelRegistration struct{ capnp.Struct }
// TunnelRegistration_TypeID is the unique identifier for the type TunnelRegistration.
const TunnelRegistration_TypeID = 0xf41a0f001ad49e46
func NewTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
return TunnelRegistration{st}, err
}
func NewRootTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
return TunnelRegistration{st}, err
}
func ReadRootTunnelRegistration(msg *capnp.Message) (TunnelRegistration, error) {
root, err := msg.RootPtr()
return TunnelRegistration{root.Struct()}, err
}
func (s TunnelRegistration) String() string {
str, _ := text.Marshal(0xf41a0f001ad49e46, s.Struct)
return str
}
func (s TunnelRegistration) Err() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s TunnelRegistration) HasErr() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) ErrBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s TunnelRegistration) SetErr(v string) error {
return s.Struct.SetText(0, v)
}
func (s TunnelRegistration) Url() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s TunnelRegistration) HasUrl() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) UrlBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s TunnelRegistration) SetUrl(v string) error {
return s.Struct.SetText(1, v)
}
func (s TunnelRegistration) LogLines() (capnp.TextList, error) {
p, err := s.Struct.Ptr(2)
return capnp.TextList{List: p.List()}, err
}
func (s TunnelRegistration) HasLogLines() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) SetLogLines(v capnp.TextList) error {
return s.Struct.SetPtr(2, v.List.ToPtr())
}
// NewLogLines sets the logLines field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s TunnelRegistration) NewLogLines(n int32) (capnp.TextList, error) {
l, err := capnp.NewTextList(s.Struct.Segment(), n)
if err != nil {
return capnp.TextList{}, err
}
err = s.Struct.SetPtr(2, l.List.ToPtr())
return l, err
}
func (s TunnelRegistration) PermanentFailure() bool {
return s.Struct.Bit(0)
}
func (s TunnelRegistration) SetPermanentFailure(v bool) {
s.Struct.SetBit(0, v)
}
func (s TunnelRegistration) TunnelID() (string, error) {
p, err := s.Struct.Ptr(3)
return p.Text(), err
}
func (s TunnelRegistration) HasTunnelID() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) TunnelIDBytes() ([]byte, error) {
p, err := s.Struct.Ptr(3)
return p.TextBytes(), err
}
func (s TunnelRegistration) SetTunnelID(v string) error {
return s.Struct.SetText(3, v)
}
// TunnelRegistration_List is a list of TunnelRegistration.
type TunnelRegistration_List struct{ capnp.List }
// NewTunnelRegistration creates a new list of TunnelRegistration.
func NewTunnelRegistration_List(s *capnp.Segment, sz int32) (TunnelRegistration_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}, sz)
return TunnelRegistration_List{l}, err
}
func (s TunnelRegistration_List) At(i int) TunnelRegistration {
return TunnelRegistration{s.List.Struct(i)}
}
func (s TunnelRegistration_List) Set(i int, v TunnelRegistration) error {
return s.List.SetStruct(i, v.Struct)
}
func (s TunnelRegistration_List) String() string {
str, _ := text.MarshalList(0xf41a0f001ad49e46, s.List)
return str
}
// TunnelRegistration_Promise is a wrapper for a TunnelRegistration promised by a client call.
type TunnelRegistration_Promise struct{ *capnp.Pipeline }
func (p TunnelRegistration_Promise) Struct() (TunnelRegistration, error) {
s, err := p.Pipeline.Struct()
return TunnelRegistration{s}, err
}
type RegistrationOptions struct{ capnp.Struct }
// RegistrationOptions_TypeID is the unique identifier for the type RegistrationOptions.
const RegistrationOptions_TypeID = 0xc793e50592935b4a
func NewRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 7})
return RegistrationOptions{st}, err
}
func NewRootRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 7})
return RegistrationOptions{st}, err
}
func ReadRootRegistrationOptions(msg *capnp.Message) (RegistrationOptions, error) {
root, err := msg.RootPtr()
return RegistrationOptions{root.Struct()}, err
}
func (s RegistrationOptions) String() string {
str, _ := text.Marshal(0xc793e50592935b4a, s.Struct)
return str
}
func (s RegistrationOptions) ClientId() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s RegistrationOptions) HasClientId() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) ClientIdBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetClientId(v string) error {
return s.Struct.SetText(0, v)
}
func (s RegistrationOptions) Version() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s RegistrationOptions) HasVersion() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) VersionBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetVersion(v string) error {
return s.Struct.SetText(1, v)
}
func (s RegistrationOptions) Os() (string, error) {
p, err := s.Struct.Ptr(2)
return p.Text(), err
}
func (s RegistrationOptions) HasOs() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) OsBytes() ([]byte, error) {
p, err := s.Struct.Ptr(2)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetOs(v string) error {
return s.Struct.SetText(2, v)
}
func (s RegistrationOptions) ExistingTunnelPolicy() ExistingTunnelPolicy {
return ExistingTunnelPolicy(s.Struct.Uint16(0))
}
func (s RegistrationOptions) SetExistingTunnelPolicy(v ExistingTunnelPolicy) {
s.Struct.SetUint16(0, uint16(v))
}
func (s RegistrationOptions) PoolName() (string, error) {
p, err := s.Struct.Ptr(3)
return p.Text(), err
}
func (s RegistrationOptions) HasPoolName() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) PoolNameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(3)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetPoolName(v string) error {
return s.Struct.SetText(3, v)
}
func (s RegistrationOptions) Tags() (Tag_List, error) {
p, err := s.Struct.Ptr(4)
return Tag_List{List: p.List()}, err
}
func (s RegistrationOptions) HasTags() bool {
p, err := s.Struct.Ptr(4)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) SetTags(v Tag_List) error {
return s.Struct.SetPtr(4, v.List.ToPtr())
}
// NewTags sets the tags field to a newly
// allocated Tag_List, preferring placement in s's segment.
func (s RegistrationOptions) NewTags(n int32) (Tag_List, error) {
l, err := NewTag_List(s.Struct.Segment(), n)
if err != nil {
return Tag_List{}, err
}
err = s.Struct.SetPtr(4, l.List.ToPtr())
return l, err
}
func (s RegistrationOptions) ConnectionId() uint8 {
return s.Struct.Uint8(2)
}
func (s RegistrationOptions) SetConnectionId(v uint8) {
s.Struct.SetUint8(2, v)
}
func (s RegistrationOptions) OriginLocalIp() (string, error) {
p, err := s.Struct.Ptr(5)
return p.Text(), err
}
func (s RegistrationOptions) HasOriginLocalIp() bool {
p, err := s.Struct.Ptr(5)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) OriginLocalIpBytes() ([]byte, error) {
p, err := s.Struct.Ptr(5)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetOriginLocalIp(v string) error {
return s.Struct.SetText(5, v)
}
func (s RegistrationOptions) IsAutoupdated() bool {
return s.Struct.Bit(24)
}
func (s RegistrationOptions) SetIsAutoupdated(v bool) {
s.Struct.SetBit(24, v)
}
func (s RegistrationOptions) RunFromTerminal() bool {
return s.Struct.Bit(25)
}
func (s RegistrationOptions) SetRunFromTerminal(v bool) {
s.Struct.SetBit(25, v)
}
func (s RegistrationOptions) CompressionQuality() uint64 {
return s.Struct.Uint64(8)
}
func (s RegistrationOptions) SetCompressionQuality(v uint64) {
s.Struct.SetUint64(8, v)
}
func (s RegistrationOptions) Uuid() (string, error) {
p, err := s.Struct.Ptr(6)
return p.Text(), err
}
func (s RegistrationOptions) HasUuid() bool {
p, err := s.Struct.Ptr(6)
return p.IsValid() || err != nil
}
func (s RegistrationOptions) UuidBytes() ([]byte, error) {
p, err := s.Struct.Ptr(6)
return p.TextBytes(), err
}
func (s RegistrationOptions) SetUuid(v string) error {
return s.Struct.SetText(6, v)
}
// RegistrationOptions_List is a list of RegistrationOptions.
type RegistrationOptions_List struct{ capnp.List }
// NewRegistrationOptions creates a new list of RegistrationOptions.
func NewRegistrationOptions_List(s *capnp.Segment, sz int32) (RegistrationOptions_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 7}, sz)
return RegistrationOptions_List{l}, err
}
func (s RegistrationOptions_List) At(i int) RegistrationOptions {
return RegistrationOptions{s.List.Struct(i)}
}
func (s RegistrationOptions_List) Set(i int, v RegistrationOptions) error {
return s.List.SetStruct(i, v.Struct)
}
func (s RegistrationOptions_List) String() string {
str, _ := text.MarshalList(0xc793e50592935b4a, s.List)
return str
}
// RegistrationOptions_Promise is a wrapper for a RegistrationOptions promised by a client call.
type RegistrationOptions_Promise struct{ *capnp.Pipeline }
func (p RegistrationOptions_Promise) Struct() (RegistrationOptions, error) {
s, err := p.Pipeline.Struct()
return RegistrationOptions{s}, err
}
type CapnpConnectParameters struct{ capnp.Struct }
// CapnpConnectParameters_TypeID is the unique identifier for the type CapnpConnectParameters.
const CapnpConnectParameters_TypeID = 0xa78f37418c1077c8
func NewCapnpConnectParameters(s *capnp.Segment) (CapnpConnectParameters, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5})
return CapnpConnectParameters{st}, err
}
func NewRootCapnpConnectParameters(s *capnp.Segment) (CapnpConnectParameters, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5})
return CapnpConnectParameters{st}, err
}
func ReadRootCapnpConnectParameters(msg *capnp.Message) (CapnpConnectParameters, error) {
root, err := msg.RootPtr()
return CapnpConnectParameters{root.Struct()}, err
}
func (s CapnpConnectParameters) String() string {
str, _ := text.Marshal(0xa78f37418c1077c8, s.Struct)
return str
}
func (s CapnpConnectParameters) OriginCert() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return []byte(p.Data()), err
}
func (s CapnpConnectParameters) HasOriginCert() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s CapnpConnectParameters) SetOriginCert(v []byte) error {
return s.Struct.SetData(0, v)
}
func (s CapnpConnectParameters) CloudflaredID() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return []byte(p.Data()), err
}
func (s CapnpConnectParameters) HasCloudflaredID() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s CapnpConnectParameters) SetCloudflaredID(v []byte) error {
return s.Struct.SetData(1, v)
}
func (s CapnpConnectParameters) NumPreviousAttempts() uint8 {
return s.Struct.Uint8(0)
}
func (s CapnpConnectParameters) SetNumPreviousAttempts(v uint8) {
s.Struct.SetUint8(0, v)
}
func (s CapnpConnectParameters) Tags() (Tag_List, error) {
p, err := s.Struct.Ptr(2)
return Tag_List{List: p.List()}, err
}
func (s CapnpConnectParameters) HasTags() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s CapnpConnectParameters) SetTags(v Tag_List) error {
return s.Struct.SetPtr(2, v.List.ToPtr())
}
// NewTags sets the tags field to a newly
// allocated Tag_List, preferring placement in s's segment.
func (s CapnpConnectParameters) NewTags(n int32) (Tag_List, error) {
l, err := NewTag_List(s.Struct.Segment(), n)
if err != nil {
return Tag_List{}, err
}
err = s.Struct.SetPtr(2, l.List.ToPtr())
return l, err
}
func (s CapnpConnectParameters) CloudflaredVersion() (string, error) {
p, err := s.Struct.Ptr(3)
return p.Text(), err
}
func (s CapnpConnectParameters) HasCloudflaredVersion() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s CapnpConnectParameters) CloudflaredVersionBytes() ([]byte, error) {
p, err := s.Struct.Ptr(3)
return p.TextBytes(), err
}
func (s CapnpConnectParameters) SetCloudflaredVersion(v string) error {
return s.Struct.SetText(3, v)
}
func (s CapnpConnectParameters) Scope() (Scope, error) {
p, err := s.Struct.Ptr(4)
return Scope{Struct: p.Struct()}, err
}
func (s CapnpConnectParameters) HasScope() bool {
p, err := s.Struct.Ptr(4)
return p.IsValid() || err != nil
}
func (s CapnpConnectParameters) SetScope(v Scope) error {
return s.Struct.SetPtr(4, v.Struct.ToPtr())
}
// NewScope sets the scope field to a newly
// allocated Scope struct, preferring placement in s's segment.
func (s CapnpConnectParameters) NewScope() (Scope, error) {
ss, err := NewScope(s.Struct.Segment())
if err != nil {
return Scope{}, err
}
err = s.Struct.SetPtr(4, ss.Struct.ToPtr())
return ss, err
}
// CapnpConnectParameters_List is a list of CapnpConnectParameters.
type CapnpConnectParameters_List struct{ capnp.List }
// NewCapnpConnectParameters creates a new list of CapnpConnectParameters.
func NewCapnpConnectParameters_List(s *capnp.Segment, sz int32) (CapnpConnectParameters_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5}, sz)
return CapnpConnectParameters_List{l}, err
}
func (s CapnpConnectParameters_List) At(i int) CapnpConnectParameters {
return CapnpConnectParameters{s.List.Struct(i)}
}
func (s CapnpConnectParameters_List) Set(i int, v CapnpConnectParameters) error {
return s.List.SetStruct(i, v.Struct)
}
func (s CapnpConnectParameters_List) String() string {
str, _ := text.MarshalList(0xa78f37418c1077c8, s.List)
return str
}
// CapnpConnectParameters_Promise is a wrapper for a CapnpConnectParameters promised by a client call.
type CapnpConnectParameters_Promise struct{ *capnp.Pipeline }
func (p CapnpConnectParameters_Promise) Struct() (CapnpConnectParameters, error) {
s, err := p.Pipeline.Struct()
return CapnpConnectParameters{s}, err
}
func (p CapnpConnectParameters_Promise) Scope() Scope_Promise {
return Scope_Promise{Pipeline: p.Pipeline.GetPipeline(4)}
}
type Scope struct{ capnp.Struct }
type Scope_value Scope
type Scope_value_Which uint16
const (
Scope_value_Which_systemName Scope_value_Which = 0
Scope_value_Which_group Scope_value_Which = 1
)
func (w Scope_value_Which) String() string {
const s = "systemNamegroup"
switch w {
case Scope_value_Which_systemName:
return s[0:10]
case Scope_value_Which_group:
return s[10:15]
}
return "Scope_value_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}
// Scope_TypeID is the unique identifier for the type Scope.
const Scope_TypeID = 0xc54a4a6fd4d87596
func NewScope(s *capnp.Segment) (Scope, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return Scope{st}, err
}
func NewRootScope(s *capnp.Segment) (Scope, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return Scope{st}, err
}
func ReadRootScope(msg *capnp.Message) (Scope, error) {
root, err := msg.RootPtr()
return Scope{root.Struct()}, err
}
func (s Scope) String() string {
str, _ := text.Marshal(0xc54a4a6fd4d87596, s.Struct)
return str
}
func (s Scope) Value() Scope_value { return Scope_value(s) }
func (s Scope_value) Which() Scope_value_Which {
return Scope_value_Which(s.Struct.Uint16(0))
}
func (s Scope_value) SystemName() (string, error) {
if s.Struct.Uint16(0) != 0 {
panic("Which() != systemName")
}
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Scope_value) HasSystemName() bool {
if s.Struct.Uint16(0) != 0 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Scope_value) SystemNameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Scope_value) SetSystemName(v string) error {
s.Struct.SetUint16(0, 0)
return s.Struct.SetText(0, v)
}
func (s Scope_value) Group() (string, error) {
if s.Struct.Uint16(0) != 1 {
panic("Which() != group")
}
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Scope_value) HasGroup() bool {
if s.Struct.Uint16(0) != 1 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Scope_value) GroupBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Scope_value) SetGroup(v string) error {
s.Struct.SetUint16(0, 1)
return s.Struct.SetText(0, v)
}
// Scope_List is a list of Scope.
type Scope_List struct{ capnp.List }
// NewScope creates a new list of Scope.
func NewScope_List(s *capnp.Segment, sz int32) (Scope_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
return Scope_List{l}, err
}
func (s Scope_List) At(i int) Scope { return Scope{s.List.Struct(i)} }
func (s Scope_List) Set(i int, v Scope) error { return s.List.SetStruct(i, v.Struct) }
func (s Scope_List) String() string {
str, _ := text.MarshalList(0xc54a4a6fd4d87596, s.List)
return str
}
// Scope_Promise is a wrapper for a Scope promised by a client call.
type Scope_Promise struct{ *capnp.Pipeline }
func (p Scope_Promise) Struct() (Scope, error) {
s, err := p.Pipeline.Struct()
return Scope{s}, err
}
func (p Scope_Promise) Value() Scope_value_Promise { return Scope_value_Promise{p.Pipeline} }
// Scope_value_Promise is a wrapper for a Scope_value promised by a client call.
type Scope_value_Promise struct{ *capnp.Pipeline }
func (p Scope_value_Promise) Struct() (Scope_value, error) {
s, err := p.Pipeline.Struct()
return Scope_value{s}, err
}
type ConnectResult struct{ capnp.Struct }
// ConnectResult_TypeID is the unique identifier for the type ConnectResult.
const ConnectResult_TypeID = 0xff8d9848747c956a
func NewConnectResult(s *capnp.Segment) (ConnectResult, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
return ConnectResult{st}, err
}
func NewRootConnectResult(s *capnp.Segment) (ConnectResult, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
return ConnectResult{st}, err
}
func ReadRootConnectResult(msg *capnp.Message) (ConnectResult, error) {
root, err := msg.RootPtr()
return ConnectResult{root.Struct()}, err
}
func (s ConnectResult) String() string {
str, _ := text.Marshal(0xff8d9848747c956a, s.Struct)
return str
}
func (s ConnectResult) Err() (ConnectError, error) {
p, err := s.Struct.Ptr(0)
return ConnectError{Struct: p.Struct()}, err
}
func (s ConnectResult) HasErr() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s ConnectResult) SetErr(v ConnectError) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewErr sets the err field to a newly
// allocated ConnectError struct, preferring placement in s's segment.
func (s ConnectResult) NewErr() (ConnectError, error) {
ss, err := NewConnectError(s.Struct.Segment())
if err != nil {
return ConnectError{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
func (s ConnectResult) ServerInfo() (ServerInfo, error) {
p, err := s.Struct.Ptr(1)
return ServerInfo{Struct: p.Struct()}, err
}
func (s ConnectResult) HasServerInfo() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s ConnectResult) SetServerInfo(v ServerInfo) error {
return s.Struct.SetPtr(1, v.Struct.ToPtr())
}
// NewServerInfo sets the serverInfo field to a newly
// allocated ServerInfo struct, preferring placement in s's segment.
func (s ConnectResult) NewServerInfo() (ServerInfo, error) {
ss, err := NewServerInfo(s.Struct.Segment())
if err != nil {
return ServerInfo{}, err
}
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
return ss, err
}
// ConnectResult_List is a list of ConnectResult.
type ConnectResult_List struct{ capnp.List }
// NewConnectResult creates a new list of ConnectResult.
func NewConnectResult_List(s *capnp.Segment, sz int32) (ConnectResult_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
return ConnectResult_List{l}, err
}
func (s ConnectResult_List) At(i int) ConnectResult { return ConnectResult{s.List.Struct(i)} }
func (s ConnectResult_List) Set(i int, v ConnectResult) error { return s.List.SetStruct(i, v.Struct) }
func (s ConnectResult_List) String() string {
str, _ := text.MarshalList(0xff8d9848747c956a, s.List)
return str
}
// ConnectResult_Promise is a wrapper for a ConnectResult promised by a client call.
type ConnectResult_Promise struct{ *capnp.Pipeline }
func (p ConnectResult_Promise) Struct() (ConnectResult, error) {
s, err := p.Pipeline.Struct()
return ConnectResult{s}, err
}
func (p ConnectResult_Promise) Err() ConnectError_Promise {
return ConnectError_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
func (p ConnectResult_Promise) ServerInfo() ServerInfo_Promise {
return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
}
type ConnectError struct{ capnp.Struct }
// ConnectError_TypeID is the unique identifier for the type ConnectError.
const ConnectError_TypeID = 0xb14ce48f4e2abb0d
func NewConnectError(s *capnp.Segment) (ConnectError, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
return ConnectError{st}, err
}
func NewRootConnectError(s *capnp.Segment) (ConnectError, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
return ConnectError{st}, err
}
func ReadRootConnectError(msg *capnp.Message) (ConnectError, error) {
root, err := msg.RootPtr()
return ConnectError{root.Struct()}, err
}
func (s ConnectError) String() string {
str, _ := text.Marshal(0xb14ce48f4e2abb0d, s.Struct)
return str
}
func (s ConnectError) Cause() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s ConnectError) HasCause() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s ConnectError) CauseBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s ConnectError) SetCause(v string) error {
return s.Struct.SetText(0, v)
}
func (s ConnectError) RetryAfter() int64 {
return int64(s.Struct.Uint64(0))
}
func (s ConnectError) SetRetryAfter(v int64) {
s.Struct.SetUint64(0, uint64(v))
}
func (s ConnectError) ShouldRetry() bool {
return s.Struct.Bit(64)
}
func (s ConnectError) SetShouldRetry(v bool) {
s.Struct.SetBit(64, v)
}
// ConnectError_List is a list of ConnectError.
type ConnectError_List struct{ capnp.List }
// NewConnectError creates a new list of ConnectError.
func NewConnectError_List(s *capnp.Segment, sz int32) (ConnectError_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}, sz)
return ConnectError_List{l}, err
}
func (s ConnectError_List) At(i int) ConnectError { return ConnectError{s.List.Struct(i)} }
func (s ConnectError_List) Set(i int, v ConnectError) error { return s.List.SetStruct(i, v.Struct) }
func (s ConnectError_List) String() string {
str, _ := text.MarshalList(0xb14ce48f4e2abb0d, s.List)
return str
}
// ConnectError_Promise is a wrapper for a ConnectError promised by a client call.
type ConnectError_Promise struct{ *capnp.Pipeline }
func (p ConnectError_Promise) Struct() (ConnectError, error) {
s, err := p.Pipeline.Struct()
return ConnectError{s}, err
}
type ClientConfig struct{ capnp.Struct }
// ClientConfig_TypeID is the unique identifier for the type ClientConfig.
const ClientConfig_TypeID = 0xf0a143f1c95a678e
func NewClientConfig(s *capnp.Segment) (ClientConfig, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
return ClientConfig{st}, err
}
func NewRootClientConfig(s *capnp.Segment) (ClientConfig, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
return ClientConfig{st}, err
}
func ReadRootClientConfig(msg *capnp.Message) (ClientConfig, error) {
root, err := msg.RootPtr()
return ClientConfig{root.Struct()}, err
}
func (s ClientConfig) String() string {
str, _ := text.Marshal(0xf0a143f1c95a678e, s.Struct)
return str
}
func (s ClientConfig) Version() uint64 {
return s.Struct.Uint64(0)
}
func (s ClientConfig) SetVersion(v uint64) {
s.Struct.SetUint64(0, v)
}
func (s ClientConfig) SupervisorConfig() (SupervisorConfig, error) {
p, err := s.Struct.Ptr(0)
return SupervisorConfig{Struct: p.Struct()}, err
}
func (s ClientConfig) HasSupervisorConfig() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s ClientConfig) SetSupervisorConfig(v SupervisorConfig) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewSupervisorConfig sets the supervisorConfig field to a newly
// allocated SupervisorConfig struct, preferring placement in s's segment.
func (s ClientConfig) NewSupervisorConfig() (SupervisorConfig, error) {
ss, err := NewSupervisorConfig(s.Struct.Segment())
if err != nil {
return SupervisorConfig{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
func (s ClientConfig) EdgeConnectionConfig() (EdgeConnectionConfig, error) {
p, err := s.Struct.Ptr(1)
return EdgeConnectionConfig{Struct: p.Struct()}, err
}
func (s ClientConfig) HasEdgeConnectionConfig() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s ClientConfig) SetEdgeConnectionConfig(v EdgeConnectionConfig) error {
return s.Struct.SetPtr(1, v.Struct.ToPtr())
}
// NewEdgeConnectionConfig sets the edgeConnectionConfig field to a newly
// allocated EdgeConnectionConfig struct, preferring placement in s's segment.
func (s ClientConfig) NewEdgeConnectionConfig() (EdgeConnectionConfig, error) {
ss, err := NewEdgeConnectionConfig(s.Struct.Segment())
if err != nil {
return EdgeConnectionConfig{}, err
}
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
return ss, err
}
func (s ClientConfig) DohProxyConfigs() (DoHProxyConfig_List, error) {
p, err := s.Struct.Ptr(2)
return DoHProxyConfig_List{List: p.List()}, err
}
func (s ClientConfig) HasDohProxyConfigs() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s ClientConfig) SetDohProxyConfigs(v DoHProxyConfig_List) error {
return s.Struct.SetPtr(2, v.List.ToPtr())
}
// NewDohProxyConfigs sets the dohProxyConfigs field to a newly
// allocated DoHProxyConfig_List, preferring placement in s's segment.
func (s ClientConfig) NewDohProxyConfigs(n int32) (DoHProxyConfig_List, error) {
l, err := NewDoHProxyConfig_List(s.Struct.Segment(), n)
if err != nil {
return DoHProxyConfig_List{}, err
}
err = s.Struct.SetPtr(2, l.List.ToPtr())
return l, err
}
func (s ClientConfig) ReverseProxyConfigs() (ReverseProxyConfig_List, error) {
p, err := s.Struct.Ptr(3)
return ReverseProxyConfig_List{List: p.List()}, err
}
func (s ClientConfig) HasReverseProxyConfigs() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s ClientConfig) SetReverseProxyConfigs(v ReverseProxyConfig_List) error {
return s.Struct.SetPtr(3, v.List.ToPtr())
}
// NewReverseProxyConfigs sets the reverseProxyConfigs field to a newly
// allocated ReverseProxyConfig_List, preferring placement in s's segment.
func (s ClientConfig) NewReverseProxyConfigs(n int32) (ReverseProxyConfig_List, error) {
l, err := NewReverseProxyConfig_List(s.Struct.Segment(), n)
if err != nil {
return ReverseProxyConfig_List{}, err
}
err = s.Struct.SetPtr(3, l.List.ToPtr())
return l, err
}
// ClientConfig_List is a list of ClientConfig.
type ClientConfig_List struct{ capnp.List }
// NewClientConfig creates a new list of ClientConfig.
func NewClientConfig_List(s *capnp.Segment, sz int32) (ClientConfig_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}, sz)
return ClientConfig_List{l}, err
}
func (s ClientConfig_List) At(i int) ClientConfig { return ClientConfig{s.List.Struct(i)} }
func (s ClientConfig_List) Set(i int, v ClientConfig) error { return s.List.SetStruct(i, v.Struct) }
func (s ClientConfig_List) String() string {
str, _ := text.MarshalList(0xf0a143f1c95a678e, s.List)
return str
}
// ClientConfig_Promise is a wrapper for a ClientConfig promised by a client call.
type ClientConfig_Promise struct{ *capnp.Pipeline }
func (p ClientConfig_Promise) Struct() (ClientConfig, error) {
s, err := p.Pipeline.Struct()
return ClientConfig{s}, err
}
func (p ClientConfig_Promise) SupervisorConfig() SupervisorConfig_Promise {
return SupervisorConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
func (p ClientConfig_Promise) EdgeConnectionConfig() EdgeConnectionConfig_Promise {
return EdgeConnectionConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
}
type SupervisorConfig struct{ capnp.Struct }
// SupervisorConfig_TypeID is the unique identifier for the type SupervisorConfig.
const SupervisorConfig_TypeID = 0xf7f49b3f779ae258
func NewSupervisorConfig(s *capnp.Segment) (SupervisorConfig, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0})
return SupervisorConfig{st}, err
}
func NewRootSupervisorConfig(s *capnp.Segment) (SupervisorConfig, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0})
return SupervisorConfig{st}, err
}
func ReadRootSupervisorConfig(msg *capnp.Message) (SupervisorConfig, error) {
root, err := msg.RootPtr()
return SupervisorConfig{root.Struct()}, err
}
func (s SupervisorConfig) String() string {
str, _ := text.Marshal(0xf7f49b3f779ae258, s.Struct)
return str
}
func (s SupervisorConfig) AutoUpdateFrequency() int64 {
return int64(s.Struct.Uint64(0))
}
func (s SupervisorConfig) SetAutoUpdateFrequency(v int64) {
s.Struct.SetUint64(0, uint64(v))
}
func (s SupervisorConfig) MetricsUpdateFrequency() int64 {
return int64(s.Struct.Uint64(8))
}
func (s SupervisorConfig) SetMetricsUpdateFrequency(v int64) {
s.Struct.SetUint64(8, uint64(v))
}
func (s SupervisorConfig) GracePeriod() int64 {
return int64(s.Struct.Uint64(16))
}
func (s SupervisorConfig) SetGracePeriod(v int64) {
s.Struct.SetUint64(16, uint64(v))
}
// SupervisorConfig_List is a list of SupervisorConfig.
type SupervisorConfig_List struct{ capnp.List }
// NewSupervisorConfig creates a new list of SupervisorConfig.
func NewSupervisorConfig_List(s *capnp.Segment, sz int32) (SupervisorConfig_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0}, sz)
return SupervisorConfig_List{l}, err
}
func (s SupervisorConfig_List) At(i int) SupervisorConfig { return SupervisorConfig{s.List.Struct(i)} }
func (s SupervisorConfig_List) Set(i int, v SupervisorConfig) error {
return s.List.SetStruct(i, v.Struct)
}
func (s SupervisorConfig_List) String() string {
str, _ := text.MarshalList(0xf7f49b3f779ae258, s.List)
return str
}
// SupervisorConfig_Promise is a wrapper for a SupervisorConfig promised by a client call.
type SupervisorConfig_Promise struct{ *capnp.Pipeline }
func (p SupervisorConfig_Promise) Struct() (SupervisorConfig, error) {
s, err := p.Pipeline.Struct()
return SupervisorConfig{s}, err
}
type EdgeConnectionConfig struct{ capnp.Struct }
// EdgeConnectionConfig_TypeID is the unique identifier for the type EdgeConnectionConfig.
const EdgeConnectionConfig_TypeID = 0xc744e349009087aa
func NewEdgeConnectionConfig(s *capnp.Segment) (EdgeConnectionConfig, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1})
return EdgeConnectionConfig{st}, err
}
func NewRootEdgeConnectionConfig(s *capnp.Segment) (EdgeConnectionConfig, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1})
return EdgeConnectionConfig{st}, err
}
func ReadRootEdgeConnectionConfig(msg *capnp.Message) (EdgeConnectionConfig, error) {
root, err := msg.RootPtr()
return EdgeConnectionConfig{root.Struct()}, err
}
func (s EdgeConnectionConfig) String() string {
str, _ := text.Marshal(0xc744e349009087aa, s.Struct)
return str
}
func (s EdgeConnectionConfig) NumHAConnections() uint8 {
return s.Struct.Uint8(0)
}
func (s EdgeConnectionConfig) SetNumHAConnections(v uint8) {
s.Struct.SetUint8(0, v)
}
func (s EdgeConnectionConfig) HeartbeatInterval() int64 {
return int64(s.Struct.Uint64(8))
}
func (s EdgeConnectionConfig) SetHeartbeatInterval(v int64) {
s.Struct.SetUint64(8, uint64(v))
}
func (s EdgeConnectionConfig) Timeout() int64 {
return int64(s.Struct.Uint64(16))
}
func (s EdgeConnectionConfig) SetTimeout(v int64) {
s.Struct.SetUint64(16, uint64(v))
}
func (s EdgeConnectionConfig) MaxFailedHeartbeats() uint64 {
return s.Struct.Uint64(24)
}
func (s EdgeConnectionConfig) SetMaxFailedHeartbeats(v uint64) {
s.Struct.SetUint64(24, v)
}
func (s EdgeConnectionConfig) UserCredentialPath() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s EdgeConnectionConfig) HasUserCredentialPath() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s EdgeConnectionConfig) UserCredentialPathBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s EdgeConnectionConfig) SetUserCredentialPath(v string) error {
return s.Struct.SetText(0, v)
}
// EdgeConnectionConfig_List is a list of EdgeConnectionConfig.
type EdgeConnectionConfig_List struct{ capnp.List }
// NewEdgeConnectionConfig creates a new list of EdgeConnectionConfig.
func NewEdgeConnectionConfig_List(s *capnp.Segment, sz int32) (EdgeConnectionConfig_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1}, sz)
return EdgeConnectionConfig_List{l}, err
}
func (s EdgeConnectionConfig_List) At(i int) EdgeConnectionConfig {
return EdgeConnectionConfig{s.List.Struct(i)}
}
func (s EdgeConnectionConfig_List) Set(i int, v EdgeConnectionConfig) error {
return s.List.SetStruct(i, v.Struct)
}
func (s EdgeConnectionConfig_List) String() string {
str, _ := text.MarshalList(0xc744e349009087aa, s.List)
return str
}
// EdgeConnectionConfig_Promise is a wrapper for a EdgeConnectionConfig promised by a client call.
type EdgeConnectionConfig_Promise struct{ *capnp.Pipeline }
func (p EdgeConnectionConfig_Promise) Struct() (EdgeConnectionConfig, error) {
s, err := p.Pipeline.Struct()
return EdgeConnectionConfig{s}, err
}
type ReverseProxyConfig struct{ capnp.Struct }
type ReverseProxyConfig_origin ReverseProxyConfig
type ReverseProxyConfig_origin_Which uint16
const (
ReverseProxyConfig_origin_Which_http ReverseProxyConfig_origin_Which = 0
ReverseProxyConfig_origin_Which_websocket ReverseProxyConfig_origin_Which = 1
ReverseProxyConfig_origin_Which_helloWorld ReverseProxyConfig_origin_Which = 2
)
func (w ReverseProxyConfig_origin_Which) String() string {
const s = "httpwebsockethelloWorld"
switch w {
case ReverseProxyConfig_origin_Which_http:
return s[0:4]
case ReverseProxyConfig_origin_Which_websocket:
return s[4:13]
case ReverseProxyConfig_origin_Which_helloWorld:
return s[13:23]
}
return "ReverseProxyConfig_origin_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) Origin() ReverseProxyConfig_origin { return ReverseProxyConfig_origin(s) }
func (s ReverseProxyConfig_origin) Which() ReverseProxyConfig_origin_Which {
return ReverseProxyConfig_origin_Which(s.Struct.Uint16(0))
}
func (s ReverseProxyConfig_origin) Http() (HTTPOriginConfig, error) {
if s.Struct.Uint16(0) != 0 {
panic("Which() != http")
}
p, err := s.Struct.Ptr(1)
return HTTPOriginConfig{Struct: p.Struct()}, err
}
func (s ReverseProxyConfig_origin) HasHttp() bool {
if s.Struct.Uint16(0) != 0 {
return false
}
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s ReverseProxyConfig_origin) 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_origin) 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_origin) Websocket() (WebSocketOriginConfig, error) {
if s.Struct.Uint16(0) != 1 {
panic("Which() != websocket")
}
p, err := s.Struct.Ptr(1)
return WebSocketOriginConfig{Struct: p.Struct()}, err
}
func (s ReverseProxyConfig_origin) HasWebsocket() bool {
if s.Struct.Uint16(0) != 1 {
return false
}
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s ReverseProxyConfig_origin) 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_origin) 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_origin) HelloWorld() (HelloWorldOriginConfig, error) {
if s.Struct.Uint16(0) != 2 {
panic("Which() != helloWorld")
}
p, err := s.Struct.Ptr(1)
return HelloWorldOriginConfig{Struct: p.Struct()}, err
}
func (s ReverseProxyConfig_origin) HasHelloWorld() bool {
if s.Struct.Uint16(0) != 2 {
return false
}
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s ReverseProxyConfig_origin) 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_origin) NewHelloWorld() (HelloWorldOriginConfig, error) {
s.Struct.SetUint16(0, 2)
ss, err := NewHelloWorldOriginConfig(s.Struct.Segment())
if err != nil {
return HelloWorldOriginConfig{}, err
}
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
return ss, err
}
func (s ReverseProxyConfig) Retries() uint64 {
return s.Struct.Uint64(8)
}
func (s ReverseProxyConfig) SetRetries(v uint64) {
s.Struct.SetUint64(8, v)
}
func (s ReverseProxyConfig) ConnectionTimeout() int64 {
return int64(s.Struct.Uint64(16))
}
func (s ReverseProxyConfig) SetConnectionTimeout(v int64) {
s.Struct.SetUint64(16, uint64(v))
}
func (s ReverseProxyConfig) CompressionQuality() uint64 {
return s.Struct.Uint64(24)
}
func (s ReverseProxyConfig) SetCompressionQuality(v uint64) {
s.Struct.SetUint64(24, v)
}
// ReverseProxyConfig_List is a list of ReverseProxyConfig.
type ReverseProxyConfig_List struct{ capnp.List }
// NewReverseProxyConfig creates a new list of ReverseProxyConfig.
func NewReverseProxyConfig_List(s *capnp.Segment, sz int32) (ReverseProxyConfig_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 32, PointerCount: 2}, sz)
return ReverseProxyConfig_List{l}, err
}
func (s ReverseProxyConfig_List) At(i int) ReverseProxyConfig {
return ReverseProxyConfig{s.List.Struct(i)}
}
func (s ReverseProxyConfig_List) Set(i int, v ReverseProxyConfig) error {
return s.List.SetStruct(i, v.Struct)
}
func (s ReverseProxyConfig_List) String() string {
str, _ := text.MarshalList(0xc766a92976e389c4, s.List)
return str
}
// ReverseProxyConfig_Promise is a wrapper for a ReverseProxyConfig promised by a client call.
type ReverseProxyConfig_Promise struct{ *capnp.Pipeline }
func (p ReverseProxyConfig_Promise) Struct() (ReverseProxyConfig, error) {
s, err := p.Pipeline.Struct()
return ReverseProxyConfig{s}, err
}
func (p ReverseProxyConfig_Promise) Origin() ReverseProxyConfig_origin_Promise {
return ReverseProxyConfig_origin_Promise{p.Pipeline}
}
// ReverseProxyConfig_origin_Promise is a wrapper for a ReverseProxyConfig_origin promised by a client call.
type ReverseProxyConfig_origin_Promise struct{ *capnp.Pipeline }
func (p ReverseProxyConfig_origin_Promise) Struct() (ReverseProxyConfig_origin, error) {
s, err := p.Pipeline.Struct()
return ReverseProxyConfig_origin{s}, err
}
func (p ReverseProxyConfig_origin_Promise) Http() HTTPOriginConfig_Promise {
return HTTPOriginConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
}
func (p ReverseProxyConfig_origin_Promise) Websocket() WebSocketOriginConfig_Promise {
return WebSocketOriginConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
}
func (p ReverseProxyConfig_origin_Promise) HelloWorld() HelloWorldOriginConfig_Promise {
return HelloWorldOriginConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
}
type WebSocketOriginConfig struct{ capnp.Struct }
// WebSocketOriginConfig_TypeID is the unique identifier for the type WebSocketOriginConfig.
const WebSocketOriginConfig_TypeID = 0xf9c895683ed9ac4c
func NewWebSocketOriginConfig(s *capnp.Segment) (WebSocketOriginConfig, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
return WebSocketOriginConfig{st}, err
}
func NewRootWebSocketOriginConfig(s *capnp.Segment) (WebSocketOriginConfig, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
return WebSocketOriginConfig{st}, err
}
func ReadRootWebSocketOriginConfig(msg *capnp.Message) (WebSocketOriginConfig, error) {
root, err := msg.RootPtr()
return WebSocketOriginConfig{root.Struct()}, err
}
func (s WebSocketOriginConfig) String() string {
str, _ := text.Marshal(0xf9c895683ed9ac4c, s.Struct)
return str
}
func (s WebSocketOriginConfig) UrlString() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s WebSocketOriginConfig) HasUrlString() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s WebSocketOriginConfig) UrlStringBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s WebSocketOriginConfig) SetUrlString(v string) error {
return s.Struct.SetText(0, v)
}
func (s WebSocketOriginConfig) TlsVerify() bool {
return s.Struct.Bit(0)
}
func (s WebSocketOriginConfig) SetTlsVerify(v bool) {
s.Struct.SetBit(0, v)
}
func (s WebSocketOriginConfig) OriginCAPool() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s WebSocketOriginConfig) HasOriginCAPool() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s WebSocketOriginConfig) OriginCAPoolBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s WebSocketOriginConfig) SetOriginCAPool(v string) error {
return s.Struct.SetText(1, v)
}
func (s WebSocketOriginConfig) OriginServerName() (string, error) {
p, err := s.Struct.Ptr(2)
return p.Text(), err
}
func (s WebSocketOriginConfig) HasOriginServerName() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s WebSocketOriginConfig) OriginServerNameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(2)
return p.TextBytes(), err
}
func (s WebSocketOriginConfig) SetOriginServerName(v string) error {
return s.Struct.SetText(2, v)
}
// WebSocketOriginConfig_List is a list of WebSocketOriginConfig.
type WebSocketOriginConfig_List struct{ capnp.List }
// NewWebSocketOriginConfig creates a new list of WebSocketOriginConfig.
func NewWebSocketOriginConfig_List(s *capnp.Segment, sz int32) (WebSocketOriginConfig_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}, sz)
return WebSocketOriginConfig_List{l}, err
}
func (s WebSocketOriginConfig_List) At(i int) WebSocketOriginConfig {
return WebSocketOriginConfig{s.List.Struct(i)}
}
func (s WebSocketOriginConfig_List) Set(i int, v WebSocketOriginConfig) error {
return s.List.SetStruct(i, v.Struct)
}
func (s WebSocketOriginConfig_List) String() string {
str, _ := text.MarshalList(0xf9c895683ed9ac4c, s.List)
return str
}
// WebSocketOriginConfig_Promise is a wrapper for a WebSocketOriginConfig promised by a client call.
type WebSocketOriginConfig_Promise struct{ *capnp.Pipeline }
func (p WebSocketOriginConfig_Promise) Struct() (WebSocketOriginConfig, error) {
s, err := p.Pipeline.Struct()
return WebSocketOriginConfig{s}, err
}
type HTTPOriginConfig struct{ capnp.Struct }
// HTTPOriginConfig_TypeID is the unique identifier for the type HTTPOriginConfig.
const HTTPOriginConfig_TypeID = 0xe4a6a1bc139211b4
func NewHTTPOriginConfig(s *capnp.Segment) (HTTPOriginConfig, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 56, PointerCount: 3})
return HTTPOriginConfig{st}, err
}
func NewRootHTTPOriginConfig(s *capnp.Segment) (HTTPOriginConfig, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 56, PointerCount: 3})
return HTTPOriginConfig{st}, err
}
func ReadRootHTTPOriginConfig(msg *capnp.Message) (HTTPOriginConfig, error) {
root, err := msg.RootPtr()
return HTTPOriginConfig{root.Struct()}, err
}
func (s HTTPOriginConfig) String() string {
str, _ := text.Marshal(0xe4a6a1bc139211b4, s.Struct)
return str
}
func (s HTTPOriginConfig) UrlString() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s HTTPOriginConfig) HasUrlString() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s HTTPOriginConfig) UrlStringBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s HTTPOriginConfig) SetUrlString(v string) error {
return s.Struct.SetText(0, v)
}
func (s HTTPOriginConfig) TcpKeepAlive() int64 {
return int64(s.Struct.Uint64(0))
}
func (s HTTPOriginConfig) SetTcpKeepAlive(v int64) {
s.Struct.SetUint64(0, uint64(v))
}
func (s HTTPOriginConfig) DialDualStack() bool {
return s.Struct.Bit(64)
}
func (s HTTPOriginConfig) SetDialDualStack(v bool) {
s.Struct.SetBit(64, v)
}
func (s HTTPOriginConfig) TlsHandshakeTimeout() int64 {
return int64(s.Struct.Uint64(16))
}
func (s HTTPOriginConfig) SetTlsHandshakeTimeout(v int64) {
s.Struct.SetUint64(16, uint64(v))
}
func (s HTTPOriginConfig) TlsVerify() bool {
return s.Struct.Bit(65)
}
func (s HTTPOriginConfig) SetTlsVerify(v bool) {
s.Struct.SetBit(65, v)
}
func (s HTTPOriginConfig) OriginCAPool() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s HTTPOriginConfig) HasOriginCAPool() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s HTTPOriginConfig) OriginCAPoolBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s HTTPOriginConfig) SetOriginCAPool(v string) error {
return s.Struct.SetText(1, v)
}
func (s HTTPOriginConfig) OriginServerName() (string, error) {
p, err := s.Struct.Ptr(2)
return p.Text(), err
}
func (s HTTPOriginConfig) HasOriginServerName() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s HTTPOriginConfig) OriginServerNameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(2)
return p.TextBytes(), err
}
func (s HTTPOriginConfig) SetOriginServerName(v string) error {
return s.Struct.SetText(2, v)
}
func (s HTTPOriginConfig) MaxIdleConnections() uint64 {
return s.Struct.Uint64(24)
}
func (s HTTPOriginConfig) SetMaxIdleConnections(v uint64) {
s.Struct.SetUint64(24, v)
}
func (s HTTPOriginConfig) IdleConnectionTimeout() int64 {
return int64(s.Struct.Uint64(32))
}
func (s HTTPOriginConfig) SetIdleConnectionTimeout(v int64) {
s.Struct.SetUint64(32, uint64(v))
}
func (s HTTPOriginConfig) ProxyConnectionTimeout() int64 {
return int64(s.Struct.Uint64(40))
}
func (s HTTPOriginConfig) SetProxyConnectionTimeout(v int64) {
s.Struct.SetUint64(40, uint64(v))
}
func (s HTTPOriginConfig) ExpectContinueTimeout() int64 {
return int64(s.Struct.Uint64(48))
}
func (s HTTPOriginConfig) SetExpectContinueTimeout(v int64) {
s.Struct.SetUint64(48, uint64(v))
}
func (s HTTPOriginConfig) ChunkedEncoding() bool {
return s.Struct.Bit(66)
}
func (s HTTPOriginConfig) SetChunkedEncoding(v bool) {
s.Struct.SetBit(66, v)
}
// HTTPOriginConfig_List is a list of HTTPOriginConfig.
type HTTPOriginConfig_List struct{ capnp.List }
// NewHTTPOriginConfig creates a new list of HTTPOriginConfig.
func NewHTTPOriginConfig_List(s *capnp.Segment, sz int32) (HTTPOriginConfig_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 56, PointerCount: 3}, sz)
return HTTPOriginConfig_List{l}, err
}
func (s HTTPOriginConfig_List) At(i int) HTTPOriginConfig { return HTTPOriginConfig{s.List.Struct(i)} }
func (s HTTPOriginConfig_List) Set(i int, v HTTPOriginConfig) error {
return s.List.SetStruct(i, v.Struct)
}
func (s HTTPOriginConfig_List) String() string {
str, _ := text.MarshalList(0xe4a6a1bc139211b4, s.List)
return str
}
// HTTPOriginConfig_Promise is a wrapper for a HTTPOriginConfig promised by a client call.
type HTTPOriginConfig_Promise struct{ *capnp.Pipeline }
func (p HTTPOriginConfig_Promise) Struct() (HTTPOriginConfig, error) {
s, err := p.Pipeline.Struct()
return HTTPOriginConfig{s}, err
}
type DoHProxyConfig struct{ capnp.Struct }
// DoHProxyConfig_TypeID is the unique identifier for the type DoHProxyConfig.
const DoHProxyConfig_TypeID = 0xb167b0bebe562cd0
func NewDoHProxyConfig(s *capnp.Segment) (DoHProxyConfig, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
return DoHProxyConfig{st}, err
}
func NewRootDoHProxyConfig(s *capnp.Segment) (DoHProxyConfig, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
return DoHProxyConfig{st}, err
}
func ReadRootDoHProxyConfig(msg *capnp.Message) (DoHProxyConfig, error) {
root, err := msg.RootPtr()
return DoHProxyConfig{root.Struct()}, err
}
func (s DoHProxyConfig) String() string {
str, _ := text.Marshal(0xb167b0bebe562cd0, s.Struct)
return str
}
func (s DoHProxyConfig) ListenHost() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s DoHProxyConfig) HasListenHost() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s DoHProxyConfig) ListenHostBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s DoHProxyConfig) SetListenHost(v string) error {
return s.Struct.SetText(0, v)
}
func (s DoHProxyConfig) ListenPort() uint16 {
return s.Struct.Uint16(0)
}
func (s DoHProxyConfig) SetListenPort(v uint16) {
s.Struct.SetUint16(0, v)
}
func (s DoHProxyConfig) Upstreams() (capnp.TextList, error) {
p, err := s.Struct.Ptr(1)
return capnp.TextList{List: p.List()}, err
}
func (s DoHProxyConfig) HasUpstreams() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s DoHProxyConfig) SetUpstreams(v capnp.TextList) error {
return s.Struct.SetPtr(1, v.List.ToPtr())
}
// NewUpstreams sets the upstreams field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s DoHProxyConfig) NewUpstreams(n int32) (capnp.TextList, error) {
l, err := capnp.NewTextList(s.Struct.Segment(), n)
if err != nil {
return capnp.TextList{}, err
}
err = s.Struct.SetPtr(1, l.List.ToPtr())
return l, err
}
// DoHProxyConfig_List is a list of DoHProxyConfig.
type DoHProxyConfig_List struct{ capnp.List }
// NewDoHProxyConfig creates a new list of DoHProxyConfig.
func NewDoHProxyConfig_List(s *capnp.Segment, sz int32) (DoHProxyConfig_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
return DoHProxyConfig_List{l}, err
}
func (s DoHProxyConfig_List) At(i int) DoHProxyConfig { return DoHProxyConfig{s.List.Struct(i)} }
func (s DoHProxyConfig_List) Set(i int, v DoHProxyConfig) error { return s.List.SetStruct(i, v.Struct) }
func (s DoHProxyConfig_List) String() string {
str, _ := text.MarshalList(0xb167b0bebe562cd0, s.List)
return str
}
// DoHProxyConfig_Promise is a wrapper for a DoHProxyConfig promised by a client call.
type DoHProxyConfig_Promise struct{ *capnp.Pipeline }
func (p DoHProxyConfig_Promise) Struct() (DoHProxyConfig, error) {
s, err := p.Pipeline.Struct()
return DoHProxyConfig{s}, err
}
type HelloWorldOriginConfig struct{ capnp.Struct }
// HelloWorldOriginConfig_TypeID is the unique identifier for the type HelloWorldOriginConfig.
const HelloWorldOriginConfig_TypeID = 0x8891f360e47c30d3
func NewHelloWorldOriginConfig(s *capnp.Segment) (HelloWorldOriginConfig, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
return HelloWorldOriginConfig{st}, err
}
func NewRootHelloWorldOriginConfig(s *capnp.Segment) (HelloWorldOriginConfig, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
return HelloWorldOriginConfig{st}, err
}
func ReadRootHelloWorldOriginConfig(msg *capnp.Message) (HelloWorldOriginConfig, error) {
root, err := msg.RootPtr()
return HelloWorldOriginConfig{root.Struct()}, err
}
func (s HelloWorldOriginConfig) String() string {
str, _ := text.Marshal(0x8891f360e47c30d3, s.Struct)
return str
}
// HelloWorldOriginConfig_List is a list of HelloWorldOriginConfig.
type HelloWorldOriginConfig_List struct{ capnp.List }
// NewHelloWorldOriginConfig creates a new list of HelloWorldOriginConfig.
func NewHelloWorldOriginConfig_List(s *capnp.Segment, sz int32) (HelloWorldOriginConfig_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
return HelloWorldOriginConfig_List{l}, err
}
func (s HelloWorldOriginConfig_List) At(i int) HelloWorldOriginConfig {
return HelloWorldOriginConfig{s.List.Struct(i)}
}
func (s HelloWorldOriginConfig_List) Set(i int, v HelloWorldOriginConfig) error {
return s.List.SetStruct(i, v.Struct)
}
func (s HelloWorldOriginConfig_List) String() string {
str, _ := text.MarshalList(0x8891f360e47c30d3, s.List)
return str
}
// HelloWorldOriginConfig_Promise is a wrapper for a HelloWorldOriginConfig promised by a client call.
type HelloWorldOriginConfig_Promise struct{ *capnp.Pipeline }
func (p HelloWorldOriginConfig_Promise) Struct() (HelloWorldOriginConfig, error) {
s, err := p.Pipeline.Struct()
return HelloWorldOriginConfig{s}, err
}
type Tag struct{ capnp.Struct }
// Tag_TypeID is the unique identifier for the type Tag.
const Tag_TypeID = 0xcbd96442ae3bb01a
func NewTag(s *capnp.Segment) (Tag, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
return Tag{st}, err
}
func NewRootTag(s *capnp.Segment) (Tag, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
return Tag{st}, err
}
func ReadRootTag(msg *capnp.Message) (Tag, error) {
root, err := msg.RootPtr()
return Tag{root.Struct()}, err
}
func (s Tag) String() string {
str, _ := text.Marshal(0xcbd96442ae3bb01a, s.Struct)
return str
}
func (s Tag) Name() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Tag) HasName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Tag) NameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Tag) SetName(v string) error {
return s.Struct.SetText(0, v)
}
func (s Tag) Value() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s Tag) HasValue() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s Tag) ValueBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s Tag) SetValue(v string) error {
return s.Struct.SetText(1, v)
}
// Tag_List is a list of Tag.
type Tag_List struct{ capnp.List }
// NewTag creates a new list of Tag.
func NewTag_List(s *capnp.Segment, sz int32) (Tag_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
return Tag_List{l}, err
}
func (s Tag_List) At(i int) Tag { return Tag{s.List.Struct(i)} }
func (s Tag_List) Set(i int, v Tag) error { return s.List.SetStruct(i, v.Struct) }
func (s Tag_List) String() string {
str, _ := text.MarshalList(0xcbd96442ae3bb01a, s.List)
return str
}
// Tag_Promise is a wrapper for a Tag promised by a client call.
type Tag_Promise struct{ *capnp.Pipeline }
func (p Tag_Promise) Struct() (Tag, error) {
s, err := p.Pipeline.Struct()
return Tag{s}, err
}
type ExistingTunnelPolicy uint16
// ExistingTunnelPolicy_TypeID is the unique identifier for the type ExistingTunnelPolicy.
const ExistingTunnelPolicy_TypeID = 0x84cb9536a2cf6d3c
// Values of ExistingTunnelPolicy.
const (
ExistingTunnelPolicy_ignore ExistingTunnelPolicy = 0
ExistingTunnelPolicy_disconnect ExistingTunnelPolicy = 1
ExistingTunnelPolicy_balance ExistingTunnelPolicy = 2
)
// String returns the enum's constant name.
func (c ExistingTunnelPolicy) String() string {
switch c {
case ExistingTunnelPolicy_ignore:
return "ignore"
case ExistingTunnelPolicy_disconnect:
return "disconnect"
case ExistingTunnelPolicy_balance:
return "balance"
default:
return ""
}
}
// ExistingTunnelPolicyFromString returns the enum value with a name,
// or the zero value if there's no such value.
func ExistingTunnelPolicyFromString(c string) ExistingTunnelPolicy {
switch c {
case "ignore":
return ExistingTunnelPolicy_ignore
case "disconnect":
return ExistingTunnelPolicy_disconnect
case "balance":
return ExistingTunnelPolicy_balance
default:
return 0
}
}
type ExistingTunnelPolicy_List struct{ capnp.List }
func NewExistingTunnelPolicy_List(s *capnp.Segment, sz int32) (ExistingTunnelPolicy_List, error) {
l, err := capnp.NewUInt16List(s, sz)
return ExistingTunnelPolicy_List{l.List}, err
}
func (l ExistingTunnelPolicy_List) At(i int) ExistingTunnelPolicy {
ul := capnp.UInt16List{List: l.List}
return ExistingTunnelPolicy(ul.At(i))
}
func (l ExistingTunnelPolicy_List) Set(i int, v ExistingTunnelPolicy) {
ul := capnp.UInt16List{List: l.List}
ul.Set(i, uint16(v))
}
type ServerInfo struct{ capnp.Struct }
// ServerInfo_TypeID is the unique identifier for the type ServerInfo.
const ServerInfo_TypeID = 0xf2c68e2547ec3866
func NewServerInfo(s *capnp.Segment) (ServerInfo, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return ServerInfo{st}, err
}
func NewRootServerInfo(s *capnp.Segment) (ServerInfo, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return ServerInfo{st}, err
}
func ReadRootServerInfo(msg *capnp.Message) (ServerInfo, error) {
root, err := msg.RootPtr()
return ServerInfo{root.Struct()}, err
}
func (s ServerInfo) String() string {
str, _ := text.Marshal(0xf2c68e2547ec3866, s.Struct)
return str
}
func (s ServerInfo) LocationName() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s ServerInfo) HasLocationName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s ServerInfo) LocationNameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s ServerInfo) SetLocationName(v string) error {
return s.Struct.SetText(0, v)
}
// ServerInfo_List is a list of ServerInfo.
type ServerInfo_List struct{ capnp.List }
// NewServerInfo creates a new list of ServerInfo.
func NewServerInfo_List(s *capnp.Segment, sz int32) (ServerInfo_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return ServerInfo_List{l}, err
}
func (s ServerInfo_List) At(i int) ServerInfo { return ServerInfo{s.List.Struct(i)} }
func (s ServerInfo_List) Set(i int, v ServerInfo) error { return s.List.SetStruct(i, v.Struct) }
func (s ServerInfo_List) String() string {
str, _ := text.MarshalList(0xf2c68e2547ec3866, s.List)
return str
}
// ServerInfo_Promise is a wrapper for a ServerInfo promised by a client call.
type ServerInfo_Promise struct{ *capnp.Pipeline }
func (p ServerInfo_Promise) Struct() (ServerInfo, error) {
s, err := p.Pipeline.Struct()
return ServerInfo{s}, err
}
type UseConfigurationResult struct{ capnp.Struct }
// UseConfigurationResult_TypeID is the unique identifier for the type UseConfigurationResult.
const UseConfigurationResult_TypeID = 0xd58a254e7a792b87
func NewUseConfigurationResult(s *capnp.Segment) (UseConfigurationResult, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return UseConfigurationResult{st}, err
}
func NewRootUseConfigurationResult(s *capnp.Segment) (UseConfigurationResult, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
return UseConfigurationResult{st}, err
}
func ReadRootUseConfigurationResult(msg *capnp.Message) (UseConfigurationResult, error) {
root, err := msg.RootPtr()
return UseConfigurationResult{root.Struct()}, err
}
func (s UseConfigurationResult) String() string {
str, _ := text.Marshal(0xd58a254e7a792b87, s.Struct)
return str
}
func (s UseConfigurationResult) Success() bool {
return s.Struct.Bit(0)
}
func (s UseConfigurationResult) SetSuccess(v bool) {
s.Struct.SetBit(0, v)
}
func (s UseConfigurationResult) FailedConfigs() (FailedConfig_List, error) {
p, err := s.Struct.Ptr(0)
return FailedConfig_List{List: p.List()}, err
}
func (s UseConfigurationResult) HasFailedConfigs() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s UseConfigurationResult) SetFailedConfigs(v FailedConfig_List) error {
return s.Struct.SetPtr(0, v.List.ToPtr())
}
// NewFailedConfigs sets the failedConfigs field to a newly
// allocated FailedConfig_List, preferring placement in s's segment.
func (s UseConfigurationResult) NewFailedConfigs(n int32) (FailedConfig_List, error) {
l, err := NewFailedConfig_List(s.Struct.Segment(), n)
if err != nil {
return FailedConfig_List{}, err
}
err = s.Struct.SetPtr(0, l.List.ToPtr())
return l, err
}
// UseConfigurationResult_List is a list of UseConfigurationResult.
type UseConfigurationResult_List struct{ capnp.List }
// NewUseConfigurationResult creates a new list of UseConfigurationResult.
func NewUseConfigurationResult_List(s *capnp.Segment, sz int32) (UseConfigurationResult_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
return UseConfigurationResult_List{l}, err
}
func (s UseConfigurationResult_List) At(i int) UseConfigurationResult {
return UseConfigurationResult{s.List.Struct(i)}
}
func (s UseConfigurationResult_List) Set(i int, v UseConfigurationResult) error {
return s.List.SetStruct(i, v.Struct)
}
func (s UseConfigurationResult_List) String() string {
str, _ := text.MarshalList(0xd58a254e7a792b87, s.List)
return str
}
// UseConfigurationResult_Promise is a wrapper for a UseConfigurationResult promised by a client call.
type UseConfigurationResult_Promise struct{ *capnp.Pipeline }
func (p UseConfigurationResult_Promise) Struct() (UseConfigurationResult, error) {
s, err := p.Pipeline.Struct()
return UseConfigurationResult{s}, err
}
type FailedConfig struct{ capnp.Struct }
type FailedConfig_config FailedConfig
type FailedConfig_config_Which uint16
const (
FailedConfig_config_Which_supervisor FailedConfig_config_Which = 0
FailedConfig_config_Which_edgeConnection FailedConfig_config_Which = 1
FailedConfig_config_Which_doh FailedConfig_config_Which = 2
FailedConfig_config_Which_reverseProxy FailedConfig_config_Which = 3
)
func (w FailedConfig_config_Which) String() string {
const s = "supervisoredgeConnectiondohreverseProxy"
switch w {
case FailedConfig_config_Which_supervisor:
return s[0:10]
case FailedConfig_config_Which_edgeConnection:
return s[10:24]
case FailedConfig_config_Which_doh:
return s[24:27]
case FailedConfig_config_Which_reverseProxy:
return s[27:39]
}
return "FailedConfig_config_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}
// FailedConfig_TypeID is the unique identifier for the type FailedConfig.
const FailedConfig_TypeID = 0xea20b390b257d1a5
func NewFailedConfig(s *capnp.Segment) (FailedConfig, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
return FailedConfig{st}, err
}
func NewRootFailedConfig(s *capnp.Segment) (FailedConfig, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
return FailedConfig{st}, err
}
func ReadRootFailedConfig(msg *capnp.Message) (FailedConfig, error) {
root, err := msg.RootPtr()
return FailedConfig{root.Struct()}, err
}
func (s FailedConfig) String() string {
str, _ := text.Marshal(0xea20b390b257d1a5, s.Struct)
return str
}
func (s FailedConfig) Config() FailedConfig_config { return FailedConfig_config(s) }
func (s FailedConfig_config) Which() FailedConfig_config_Which {
return FailedConfig_config_Which(s.Struct.Uint16(0))
}
func (s FailedConfig_config) Supervisor() (SupervisorConfig, error) {
if s.Struct.Uint16(0) != 0 {
panic("Which() != supervisor")
}
p, err := s.Struct.Ptr(0)
return SupervisorConfig{Struct: p.Struct()}, err
}
func (s FailedConfig_config) HasSupervisor() bool {
if s.Struct.Uint16(0) != 0 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s FailedConfig_config) SetSupervisor(v SupervisorConfig) error {
s.Struct.SetUint16(0, 0)
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewSupervisor sets the supervisor field to a newly
// allocated SupervisorConfig struct, preferring placement in s's segment.
func (s FailedConfig_config) NewSupervisor() (SupervisorConfig, error) {
s.Struct.SetUint16(0, 0)
ss, err := NewSupervisorConfig(s.Struct.Segment())
if err != nil {
return SupervisorConfig{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
func (s FailedConfig_config) EdgeConnection() (EdgeConnectionConfig, error) {
if s.Struct.Uint16(0) != 1 {
panic("Which() != edgeConnection")
}
p, err := s.Struct.Ptr(0)
return EdgeConnectionConfig{Struct: p.Struct()}, err
}
func (s FailedConfig_config) HasEdgeConnection() bool {
if s.Struct.Uint16(0) != 1 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s FailedConfig_config) SetEdgeConnection(v EdgeConnectionConfig) error {
s.Struct.SetUint16(0, 1)
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewEdgeConnection sets the edgeConnection field to a newly
// allocated EdgeConnectionConfig struct, preferring placement in s's segment.
func (s FailedConfig_config) NewEdgeConnection() (EdgeConnectionConfig, error) {
s.Struct.SetUint16(0, 1)
ss, err := NewEdgeConnectionConfig(s.Struct.Segment())
if err != nil {
return EdgeConnectionConfig{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
func (s FailedConfig_config) Doh() (DoHProxyConfig, error) {
if s.Struct.Uint16(0) != 2 {
panic("Which() != doh")
}
p, err := s.Struct.Ptr(0)
return DoHProxyConfig{Struct: p.Struct()}, err
}
func (s FailedConfig_config) HasDoh() bool {
if s.Struct.Uint16(0) != 2 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s FailedConfig_config) SetDoh(v DoHProxyConfig) error {
s.Struct.SetUint16(0, 2)
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewDoh sets the doh field to a newly
// allocated DoHProxyConfig struct, preferring placement in s's segment.
func (s FailedConfig_config) NewDoh() (DoHProxyConfig, error) {
s.Struct.SetUint16(0, 2)
ss, err := NewDoHProxyConfig(s.Struct.Segment())
if err != nil {
return DoHProxyConfig{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
func (s FailedConfig_config) ReverseProxy() (ReverseProxyConfig, error) {
if s.Struct.Uint16(0) != 3 {
panic("Which() != reverseProxy")
}
p, err := s.Struct.Ptr(0)
return ReverseProxyConfig{Struct: p.Struct()}, err
}
func (s FailedConfig_config) HasReverseProxy() bool {
if s.Struct.Uint16(0) != 3 {
return false
}
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s FailedConfig_config) SetReverseProxy(v ReverseProxyConfig) error {
s.Struct.SetUint16(0, 3)
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewReverseProxy sets the reverseProxy field to a newly
// allocated ReverseProxyConfig struct, preferring placement in s's segment.
func (s FailedConfig_config) NewReverseProxy() (ReverseProxyConfig, error) {
s.Struct.SetUint16(0, 3)
ss, err := NewReverseProxyConfig(s.Struct.Segment())
if err != nil {
return ReverseProxyConfig{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
func (s FailedConfig) Reason() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s FailedConfig) HasReason() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s FailedConfig) ReasonBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s FailedConfig) SetReason(v string) error {
return s.Struct.SetText(1, v)
}
// FailedConfig_List is a list of FailedConfig.
type FailedConfig_List struct{ capnp.List }
// NewFailedConfig creates a new list of FailedConfig.
func NewFailedConfig_List(s *capnp.Segment, sz int32) (FailedConfig_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
return FailedConfig_List{l}, err
}
func (s FailedConfig_List) At(i int) FailedConfig { return FailedConfig{s.List.Struct(i)} }
func (s FailedConfig_List) Set(i int, v FailedConfig) error { return s.List.SetStruct(i, v.Struct) }
func (s FailedConfig_List) String() string {
str, _ := text.MarshalList(0xea20b390b257d1a5, s.List)
return str
}
// FailedConfig_Promise is a wrapper for a FailedConfig promised by a client call.
type FailedConfig_Promise struct{ *capnp.Pipeline }
func (p FailedConfig_Promise) Struct() (FailedConfig, error) {
s, err := p.Pipeline.Struct()
return FailedConfig{s}, err
}
func (p FailedConfig_Promise) Config() FailedConfig_config_Promise {
return FailedConfig_config_Promise{p.Pipeline}
}
// FailedConfig_config_Promise is a wrapper for a FailedConfig_config promised by a client call.
type FailedConfig_config_Promise struct{ *capnp.Pipeline }
func (p FailedConfig_config_Promise) Struct() (FailedConfig_config, error) {
s, err := p.Pipeline.Struct()
return FailedConfig_config{s}, err
}
func (p FailedConfig_config_Promise) Supervisor() SupervisorConfig_Promise {
return SupervisorConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
func (p FailedConfig_config_Promise) EdgeConnection() EdgeConnectionConfig_Promise {
return EdgeConnectionConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
func (p FailedConfig_config_Promise) Doh() DoHProxyConfig_Promise {
return DoHProxyConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
func (p FailedConfig_config_Promise) ReverseProxy() ReverseProxyConfig_Promise {
return ReverseProxyConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type TunnelServer struct{ Client capnp.Client }
// TunnelServer_TypeID is the unique identifier for the type TunnelServer.
const TunnelServer_TypeID = 0xea58385c65416035
func (c TunnelServer) RegisterTunnel(ctx context.Context, params func(TunnelServer_registerTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_registerTunnel_Results_Promise {
if c.Client == nil {
return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 0,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "registerTunnel",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 3}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_registerTunnel_Params{Struct: s}) }
}
return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
func (c TunnelServer) GetServerInfo(ctx context.Context, params func(TunnelServer_getServerInfo_Params) error, opts ...capnp.CallOption) TunnelServer_getServerInfo_Results_Promise {
if c.Client == nil {
return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 1,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "getServerInfo",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_getServerInfo_Params{Struct: s}) }
}
return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
func (c TunnelServer) UnregisterTunnel(ctx context.Context, params func(TunnelServer_unregisterTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_unregisterTunnel_Results_Promise {
if c.Client == nil {
return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 2,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "unregisterTunnel",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 0}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_unregisterTunnel_Params{Struct: s}) }
}
return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
func (c TunnelServer) Connect(ctx context.Context, params func(TunnelServer_connect_Params) error, opts ...capnp.CallOption) TunnelServer_connect_Results_Promise {
if c.Client == nil {
return TunnelServer_connect_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 3,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "connect",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_connect_Params{Struct: s}) }
}
return TunnelServer_connect_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
type TunnelServer_Server interface {
RegisterTunnel(TunnelServer_registerTunnel) error
GetServerInfo(TunnelServer_getServerInfo) error
UnregisterTunnel(TunnelServer_unregisterTunnel) error
Connect(TunnelServer_connect) error
}
func TunnelServer_ServerToClient(s TunnelServer_Server) TunnelServer {
c, _ := s.(server.Closer)
return TunnelServer{Client: server.New(TunnelServer_Methods(nil, s), c)}
}
func TunnelServer_Methods(methods []server.Method, s TunnelServer_Server) []server.Method {
if cap(methods) == 0 {
methods = make([]server.Method, 0, 4)
}
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 0,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "registerTunnel",
},
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
call := TunnelServer_registerTunnel{c, opts, TunnelServer_registerTunnel_Params{Struct: p}, TunnelServer_registerTunnel_Results{Struct: r}}
return s.RegisterTunnel(call)
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
})
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 1,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "getServerInfo",
},
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
call := TunnelServer_getServerInfo{c, opts, TunnelServer_getServerInfo_Params{Struct: p}, TunnelServer_getServerInfo_Results{Struct: r}}
return s.GetServerInfo(call)
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
})
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 2,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "unregisterTunnel",
},
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
call := TunnelServer_unregisterTunnel{c, opts, TunnelServer_unregisterTunnel_Params{Struct: p}, TunnelServer_unregisterTunnel_Results{Struct: r}}
return s.UnregisterTunnel(call)
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
})
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 3,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "connect",
},
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
call := TunnelServer_connect{c, opts, TunnelServer_connect_Params{Struct: p}, TunnelServer_connect_Results{Struct: r}}
return s.Connect(call)
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
})
return methods
}
// TunnelServer_registerTunnel holds the arguments for a server call to TunnelServer.registerTunnel.
type TunnelServer_registerTunnel struct {
Ctx context.Context
Options capnp.CallOptions
Params TunnelServer_registerTunnel_Params
Results TunnelServer_registerTunnel_Results
}
// TunnelServer_getServerInfo holds the arguments for a server call to TunnelServer.getServerInfo.
type TunnelServer_getServerInfo struct {
Ctx context.Context
Options capnp.CallOptions
Params TunnelServer_getServerInfo_Params
Results TunnelServer_getServerInfo_Results
}
// TunnelServer_unregisterTunnel holds the arguments for a server call to TunnelServer.unregisterTunnel.
type TunnelServer_unregisterTunnel struct {
Ctx context.Context
Options capnp.CallOptions
Params TunnelServer_unregisterTunnel_Params
Results TunnelServer_unregisterTunnel_Results
}
// TunnelServer_connect holds the arguments for a server call to TunnelServer.connect.
type TunnelServer_connect struct {
Ctx context.Context
Options capnp.CallOptions
Params TunnelServer_connect_Params
Results TunnelServer_connect_Results
}
type TunnelServer_registerTunnel_Params struct{ capnp.Struct }
// TunnelServer_registerTunnel_Params_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Params.
const TunnelServer_registerTunnel_Params_TypeID = 0xb70431c0dc014915
func NewTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return TunnelServer_registerTunnel_Params{st}, err
}
func NewRootTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return TunnelServer_registerTunnel_Params{st}, err
}
func ReadRootTunnelServer_registerTunnel_Params(msg *capnp.Message) (TunnelServer_registerTunnel_Params, error) {
root, err := msg.RootPtr()
return TunnelServer_registerTunnel_Params{root.Struct()}, err
}
func (s TunnelServer_registerTunnel_Params) String() string {
str, _ := text.Marshal(0xb70431c0dc014915, s.Struct)
return str
}
func (s TunnelServer_registerTunnel_Params) OriginCert() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return []byte(p.Data()), err
}
func (s TunnelServer_registerTunnel_Params) HasOriginCert() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_registerTunnel_Params) SetOriginCert(v []byte) error {
return s.Struct.SetData(0, v)
}
func (s TunnelServer_registerTunnel_Params) Hostname() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s TunnelServer_registerTunnel_Params) HasHostname() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s TunnelServer_registerTunnel_Params) HostnameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s TunnelServer_registerTunnel_Params) SetHostname(v string) error {
return s.Struct.SetText(1, v)
}
func (s TunnelServer_registerTunnel_Params) Options() (RegistrationOptions, error) {
p, err := s.Struct.Ptr(2)
return RegistrationOptions{Struct: p.Struct()}, err
}
func (s TunnelServer_registerTunnel_Params) HasOptions() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s TunnelServer_registerTunnel_Params) SetOptions(v RegistrationOptions) error {
return s.Struct.SetPtr(2, v.Struct.ToPtr())
}
// NewOptions sets the options field to a newly
// allocated RegistrationOptions struct, preferring placement in s's segment.
func (s TunnelServer_registerTunnel_Params) NewOptions() (RegistrationOptions, error) {
ss, err := NewRegistrationOptions(s.Struct.Segment())
if err != nil {
return RegistrationOptions{}, err
}
err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_registerTunnel_Params_List is a list of TunnelServer_registerTunnel_Params.
type TunnelServer_registerTunnel_Params_List struct{ capnp.List }
// NewTunnelServer_registerTunnel_Params creates a new list of TunnelServer_registerTunnel_Params.
func NewTunnelServer_registerTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Params_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
return TunnelServer_registerTunnel_Params_List{l}, err
}
func (s TunnelServer_registerTunnel_Params_List) At(i int) TunnelServer_registerTunnel_Params {
return TunnelServer_registerTunnel_Params{s.List.Struct(i)}
}
func (s TunnelServer_registerTunnel_Params_List) Set(i int, v TunnelServer_registerTunnel_Params) error {
return s.List.SetStruct(i, v.Struct)
}
func (s TunnelServer_registerTunnel_Params_List) String() string {
str, _ := text.MarshalList(0xb70431c0dc014915, s.List)
return str
}
// TunnelServer_registerTunnel_Params_Promise is a wrapper for a TunnelServer_registerTunnel_Params promised by a client call.
type TunnelServer_registerTunnel_Params_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_registerTunnel_Params_Promise) Struct() (TunnelServer_registerTunnel_Params, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_registerTunnel_Params{s}, err
}
func (p TunnelServer_registerTunnel_Params_Promise) Options() RegistrationOptions_Promise {
return RegistrationOptions_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
}
type TunnelServer_registerTunnel_Results struct{ capnp.Struct }
// TunnelServer_registerTunnel_Results_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Results.
const TunnelServer_registerTunnel_Results_TypeID = 0xf2c122394f447e8e
func NewTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_registerTunnel_Results{st}, err
}
func NewRootTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_registerTunnel_Results{st}, err
}
func ReadRootTunnelServer_registerTunnel_Results(msg *capnp.Message) (TunnelServer_registerTunnel_Results, error) {
root, err := msg.RootPtr()
return TunnelServer_registerTunnel_Results{root.Struct()}, err
}
func (s TunnelServer_registerTunnel_Results) String() string {
str, _ := text.Marshal(0xf2c122394f447e8e, s.Struct)
return str
}
func (s TunnelServer_registerTunnel_Results) Result() (TunnelRegistration, error) {
p, err := s.Struct.Ptr(0)
return TunnelRegistration{Struct: p.Struct()}, err
}
func (s TunnelServer_registerTunnel_Results) HasResult() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_registerTunnel_Results) SetResult(v TunnelRegistration) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewResult sets the result field to a newly
// allocated TunnelRegistration struct, preferring placement in s's segment.
func (s TunnelServer_registerTunnel_Results) NewResult() (TunnelRegistration, error) {
ss, err := NewTunnelRegistration(s.Struct.Segment())
if err != nil {
return TunnelRegistration{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_registerTunnel_Results_List is a list of TunnelServer_registerTunnel_Results.
type TunnelServer_registerTunnel_Results_List struct{ capnp.List }
// NewTunnelServer_registerTunnel_Results creates a new list of TunnelServer_registerTunnel_Results.
func NewTunnelServer_registerTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Results_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return TunnelServer_registerTunnel_Results_List{l}, err
}
func (s TunnelServer_registerTunnel_Results_List) At(i int) TunnelServer_registerTunnel_Results {
return TunnelServer_registerTunnel_Results{s.List.Struct(i)}
}
func (s TunnelServer_registerTunnel_Results_List) Set(i int, v TunnelServer_registerTunnel_Results) error {
return s.List.SetStruct(i, v.Struct)
}
func (s TunnelServer_registerTunnel_Results_List) String() string {
str, _ := text.MarshalList(0xf2c122394f447e8e, s.List)
return str
}
// TunnelServer_registerTunnel_Results_Promise is a wrapper for a TunnelServer_registerTunnel_Results promised by a client call.
type TunnelServer_registerTunnel_Results_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_registerTunnel_Results_Promise) Struct() (TunnelServer_registerTunnel_Results, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_registerTunnel_Results{s}, err
}
func (p TunnelServer_registerTunnel_Results_Promise) Result() TunnelRegistration_Promise {
return TunnelRegistration_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type TunnelServer_getServerInfo_Params struct{ capnp.Struct }
// TunnelServer_getServerInfo_Params_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Params.
const TunnelServer_getServerInfo_Params_TypeID = 0xdc3ed6801961e502
func NewTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
return TunnelServer_getServerInfo_Params{st}, err
}
func NewRootTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
return TunnelServer_getServerInfo_Params{st}, err
}
func ReadRootTunnelServer_getServerInfo_Params(msg *capnp.Message) (TunnelServer_getServerInfo_Params, error) {
root, err := msg.RootPtr()
return TunnelServer_getServerInfo_Params{root.Struct()}, err
}
func (s TunnelServer_getServerInfo_Params) String() string {
str, _ := text.Marshal(0xdc3ed6801961e502, s.Struct)
return str
}
// TunnelServer_getServerInfo_Params_List is a list of TunnelServer_getServerInfo_Params.
type TunnelServer_getServerInfo_Params_List struct{ capnp.List }
// NewTunnelServer_getServerInfo_Params creates a new list of TunnelServer_getServerInfo_Params.
func NewTunnelServer_getServerInfo_Params_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Params_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
return TunnelServer_getServerInfo_Params_List{l}, err
}
func (s TunnelServer_getServerInfo_Params_List) At(i int) TunnelServer_getServerInfo_Params {
return TunnelServer_getServerInfo_Params{s.List.Struct(i)}
}
func (s TunnelServer_getServerInfo_Params_List) Set(i int, v TunnelServer_getServerInfo_Params) error {
return s.List.SetStruct(i, v.Struct)
}
func (s TunnelServer_getServerInfo_Params_List) String() string {
str, _ := text.MarshalList(0xdc3ed6801961e502, s.List)
return str
}
// TunnelServer_getServerInfo_Params_Promise is a wrapper for a TunnelServer_getServerInfo_Params promised by a client call.
type TunnelServer_getServerInfo_Params_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_getServerInfo_Params_Promise) Struct() (TunnelServer_getServerInfo_Params, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_getServerInfo_Params{s}, err
}
type TunnelServer_getServerInfo_Results struct{ capnp.Struct }
// TunnelServer_getServerInfo_Results_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Results.
const TunnelServer_getServerInfo_Results_TypeID = 0xe3e37d096a5b564e
func NewTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_getServerInfo_Results{st}, err
}
func NewRootTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_getServerInfo_Results{st}, err
}
func ReadRootTunnelServer_getServerInfo_Results(msg *capnp.Message) (TunnelServer_getServerInfo_Results, error) {
root, err := msg.RootPtr()
return TunnelServer_getServerInfo_Results{root.Struct()}, err
}
func (s TunnelServer_getServerInfo_Results) String() string {
str, _ := text.Marshal(0xe3e37d096a5b564e, s.Struct)
return str
}
func (s TunnelServer_getServerInfo_Results) Result() (ServerInfo, error) {
p, err := s.Struct.Ptr(0)
return ServerInfo{Struct: p.Struct()}, err
}
func (s TunnelServer_getServerInfo_Results) HasResult() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_getServerInfo_Results) SetResult(v ServerInfo) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewResult sets the result field to a newly
// allocated ServerInfo struct, preferring placement in s's segment.
func (s TunnelServer_getServerInfo_Results) NewResult() (ServerInfo, error) {
ss, err := NewServerInfo(s.Struct.Segment())
if err != nil {
return ServerInfo{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_getServerInfo_Results_List is a list of TunnelServer_getServerInfo_Results.
type TunnelServer_getServerInfo_Results_List struct{ capnp.List }
// NewTunnelServer_getServerInfo_Results creates a new list of TunnelServer_getServerInfo_Results.
func NewTunnelServer_getServerInfo_Results_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Results_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return TunnelServer_getServerInfo_Results_List{l}, err
}
func (s TunnelServer_getServerInfo_Results_List) At(i int) TunnelServer_getServerInfo_Results {
return TunnelServer_getServerInfo_Results{s.List.Struct(i)}
}
func (s TunnelServer_getServerInfo_Results_List) Set(i int, v TunnelServer_getServerInfo_Results) error {
return s.List.SetStruct(i, v.Struct)
}
func (s TunnelServer_getServerInfo_Results_List) String() string {
str, _ := text.MarshalList(0xe3e37d096a5b564e, s.List)
return str
}
// TunnelServer_getServerInfo_Results_Promise is a wrapper for a TunnelServer_getServerInfo_Results promised by a client call.
type TunnelServer_getServerInfo_Results_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_getServerInfo_Results_Promise) Struct() (TunnelServer_getServerInfo_Results, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_getServerInfo_Results{s}, err
}
func (p TunnelServer_getServerInfo_Results_Promise) Result() ServerInfo_Promise {
return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type TunnelServer_unregisterTunnel_Params struct{ capnp.Struct }
// TunnelServer_unregisterTunnel_Params_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Params.
const TunnelServer_unregisterTunnel_Params_TypeID = 0x9b87b390babc2ccf
func NewTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
return TunnelServer_unregisterTunnel_Params{st}, err
}
func NewRootTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
return TunnelServer_unregisterTunnel_Params{st}, err
}
func ReadRootTunnelServer_unregisterTunnel_Params(msg *capnp.Message) (TunnelServer_unregisterTunnel_Params, error) {
root, err := msg.RootPtr()
return TunnelServer_unregisterTunnel_Params{root.Struct()}, err
}
func (s TunnelServer_unregisterTunnel_Params) String() string {
str, _ := text.Marshal(0x9b87b390babc2ccf, s.Struct)
return str
}
func (s TunnelServer_unregisterTunnel_Params) GracePeriodNanoSec() int64 {
return int64(s.Struct.Uint64(0))
}
func (s TunnelServer_unregisterTunnel_Params) SetGracePeriodNanoSec(v int64) {
s.Struct.SetUint64(0, uint64(v))
}
// TunnelServer_unregisterTunnel_Params_List is a list of TunnelServer_unregisterTunnel_Params.
type TunnelServer_unregisterTunnel_Params_List struct{ capnp.List }
// NewTunnelServer_unregisterTunnel_Params creates a new list of TunnelServer_unregisterTunnel_Params.
func NewTunnelServer_unregisterTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Params_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz)
return TunnelServer_unregisterTunnel_Params_List{l}, err
}
func (s TunnelServer_unregisterTunnel_Params_List) At(i int) TunnelServer_unregisterTunnel_Params {
return TunnelServer_unregisterTunnel_Params{s.List.Struct(i)}
}
func (s TunnelServer_unregisterTunnel_Params_List) Set(i int, v TunnelServer_unregisterTunnel_Params) error {
return s.List.SetStruct(i, v.Struct)
}
func (s TunnelServer_unregisterTunnel_Params_List) String() string {
str, _ := text.MarshalList(0x9b87b390babc2ccf, s.List)
return str
}
// TunnelServer_unregisterTunnel_Params_Promise is a wrapper for a TunnelServer_unregisterTunnel_Params promised by a client call.
type TunnelServer_unregisterTunnel_Params_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_unregisterTunnel_Params_Promise) Struct() (TunnelServer_unregisterTunnel_Params, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_unregisterTunnel_Params{s}, err
}
type TunnelServer_unregisterTunnel_Results struct{ capnp.Struct }
// TunnelServer_unregisterTunnel_Results_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Results.
const TunnelServer_unregisterTunnel_Results_TypeID = 0xa29a916d4ebdd894
func NewTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
return TunnelServer_unregisterTunnel_Results{st}, err
}
func NewRootTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
return TunnelServer_unregisterTunnel_Results{st}, err
}
func ReadRootTunnelServer_unregisterTunnel_Results(msg *capnp.Message) (TunnelServer_unregisterTunnel_Results, error) {
root, err := msg.RootPtr()
return TunnelServer_unregisterTunnel_Results{root.Struct()}, err
}
func (s TunnelServer_unregisterTunnel_Results) String() string {
str, _ := text.Marshal(0xa29a916d4ebdd894, s.Struct)
return str
}
// TunnelServer_unregisterTunnel_Results_List is a list of TunnelServer_unregisterTunnel_Results.
type TunnelServer_unregisterTunnel_Results_List struct{ capnp.List }
// NewTunnelServer_unregisterTunnel_Results creates a new list of TunnelServer_unregisterTunnel_Results.
func NewTunnelServer_unregisterTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Results_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
return TunnelServer_unregisterTunnel_Results_List{l}, err
}
func (s TunnelServer_unregisterTunnel_Results_List) At(i int) TunnelServer_unregisterTunnel_Results {
return TunnelServer_unregisterTunnel_Results{s.List.Struct(i)}
}
func (s TunnelServer_unregisterTunnel_Results_List) Set(i int, v TunnelServer_unregisterTunnel_Results) error {
return s.List.SetStruct(i, v.Struct)
}
func (s TunnelServer_unregisterTunnel_Results_List) String() string {
str, _ := text.MarshalList(0xa29a916d4ebdd894, s.List)
return str
}
// TunnelServer_unregisterTunnel_Results_Promise is a wrapper for a TunnelServer_unregisterTunnel_Results promised by a client call.
type TunnelServer_unregisterTunnel_Results_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_unregisterTunnel_Results_Promise) Struct() (TunnelServer_unregisterTunnel_Results, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_unregisterTunnel_Results{s}, err
}
type TunnelServer_connect_Params struct{ capnp.Struct }
// TunnelServer_connect_Params_TypeID is the unique identifier for the type TunnelServer_connect_Params.
const TunnelServer_connect_Params_TypeID = 0xa766b24d4fe5da35
func NewTunnelServer_connect_Params(s *capnp.Segment) (TunnelServer_connect_Params, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_connect_Params{st}, err
}
func NewRootTunnelServer_connect_Params(s *capnp.Segment) (TunnelServer_connect_Params, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_connect_Params{st}, err
}
func ReadRootTunnelServer_connect_Params(msg *capnp.Message) (TunnelServer_connect_Params, error) {
root, err := msg.RootPtr()
return TunnelServer_connect_Params{root.Struct()}, err
}
func (s TunnelServer_connect_Params) String() string {
str, _ := text.Marshal(0xa766b24d4fe5da35, s.Struct)
return str
}
func (s TunnelServer_connect_Params) Parameters() (CapnpConnectParameters, error) {
p, err := s.Struct.Ptr(0)
return CapnpConnectParameters{Struct: p.Struct()}, err
}
func (s TunnelServer_connect_Params) HasParameters() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_connect_Params) SetParameters(v CapnpConnectParameters) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewParameters sets the parameters field to a newly
// allocated CapnpConnectParameters struct, preferring placement in s's segment.
func (s TunnelServer_connect_Params) NewParameters() (CapnpConnectParameters, error) {
ss, err := NewCapnpConnectParameters(s.Struct.Segment())
if err != nil {
return CapnpConnectParameters{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_connect_Params_List is a list of TunnelServer_connect_Params.
type TunnelServer_connect_Params_List struct{ capnp.List }
// NewTunnelServer_connect_Params creates a new list of TunnelServer_connect_Params.
func NewTunnelServer_connect_Params_List(s *capnp.Segment, sz int32) (TunnelServer_connect_Params_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return TunnelServer_connect_Params_List{l}, err
}
func (s TunnelServer_connect_Params_List) At(i int) TunnelServer_connect_Params {
return TunnelServer_connect_Params{s.List.Struct(i)}
}
func (s TunnelServer_connect_Params_List) Set(i int, v TunnelServer_connect_Params) error {
return s.List.SetStruct(i, v.Struct)
}
func (s TunnelServer_connect_Params_List) String() string {
str, _ := text.MarshalList(0xa766b24d4fe5da35, s.List)
return str
}
// TunnelServer_connect_Params_Promise is a wrapper for a TunnelServer_connect_Params promised by a client call.
type TunnelServer_connect_Params_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_connect_Params_Promise) Struct() (TunnelServer_connect_Params, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_connect_Params{s}, err
}
func (p TunnelServer_connect_Params_Promise) Parameters() CapnpConnectParameters_Promise {
return CapnpConnectParameters_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type TunnelServer_connect_Results struct{ capnp.Struct }
// TunnelServer_connect_Results_TypeID is the unique identifier for the type TunnelServer_connect_Results.
const TunnelServer_connect_Results_TypeID = 0xfeac5c8f4899ef7c
func NewTunnelServer_connect_Results(s *capnp.Segment) (TunnelServer_connect_Results, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_connect_Results{st}, err
}
func NewRootTunnelServer_connect_Results(s *capnp.Segment) (TunnelServer_connect_Results, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return TunnelServer_connect_Results{st}, err
}
func ReadRootTunnelServer_connect_Results(msg *capnp.Message) (TunnelServer_connect_Results, error) {
root, err := msg.RootPtr()
return TunnelServer_connect_Results{root.Struct()}, err
}
func (s TunnelServer_connect_Results) String() string {
str, _ := text.Marshal(0xfeac5c8f4899ef7c, s.Struct)
return str
}
func (s TunnelServer_connect_Results) Result() (ConnectResult, error) {
p, err := s.Struct.Ptr(0)
return ConnectResult{Struct: p.Struct()}, err
}
func (s TunnelServer_connect_Results) HasResult() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelServer_connect_Results) SetResult(v ConnectResult) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewResult sets the result field to a newly
// allocated ConnectResult struct, preferring placement in s's segment.
func (s TunnelServer_connect_Results) NewResult() (ConnectResult, error) {
ss, err := NewConnectResult(s.Struct.Segment())
if err != nil {
return ConnectResult{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// TunnelServer_connect_Results_List is a list of TunnelServer_connect_Results.
type TunnelServer_connect_Results_List struct{ capnp.List }
// NewTunnelServer_connect_Results creates a new list of TunnelServer_connect_Results.
func NewTunnelServer_connect_Results_List(s *capnp.Segment, sz int32) (TunnelServer_connect_Results_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return TunnelServer_connect_Results_List{l}, err
}
func (s TunnelServer_connect_Results_List) At(i int) TunnelServer_connect_Results {
return TunnelServer_connect_Results{s.List.Struct(i)}
}
func (s TunnelServer_connect_Results_List) Set(i int, v TunnelServer_connect_Results) error {
return s.List.SetStruct(i, v.Struct)
}
func (s TunnelServer_connect_Results_List) String() string {
str, _ := text.MarshalList(0xfeac5c8f4899ef7c, s.List)
return str
}
// TunnelServer_connect_Results_Promise is a wrapper for a TunnelServer_connect_Results promised by a client call.
type TunnelServer_connect_Results_Promise struct{ *capnp.Pipeline }
func (p TunnelServer_connect_Results_Promise) Struct() (TunnelServer_connect_Results, error) {
s, err := p.Pipeline.Struct()
return TunnelServer_connect_Results{s}, err
}
func (p TunnelServer_connect_Results_Promise) Result() ConnectResult_Promise {
return ConnectResult_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type ClientService struct{ Client capnp.Client }
// ClientService_TypeID is the unique identifier for the type ClientService.
const ClientService_TypeID = 0xf143a395ed8b3133
func (c ClientService) UseConfiguration(ctx context.Context, params func(ClientService_useConfiguration_Params) error, opts ...capnp.CallOption) ClientService_useConfiguration_Results_Promise {
if c.Client == nil {
return ClientService_useConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xf143a395ed8b3133,
MethodID: 0,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:ClientService",
MethodName: "useConfiguration",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
call.ParamsFunc = func(s capnp.Struct) error { return params(ClientService_useConfiguration_Params{Struct: s}) }
}
return ClientService_useConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
type ClientService_Server interface {
UseConfiguration(ClientService_useConfiguration) error
}
func ClientService_ServerToClient(s ClientService_Server) ClientService {
c, _ := s.(server.Closer)
return ClientService{Client: server.New(ClientService_Methods(nil, s), c)}
}
func ClientService_Methods(methods []server.Method, s ClientService_Server) []server.Method {
if cap(methods) == 0 {
methods = make([]server.Method, 0, 1)
}
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xf143a395ed8b3133,
MethodID: 0,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:ClientService",
MethodName: "useConfiguration",
},
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
call := ClientService_useConfiguration{c, opts, ClientService_useConfiguration_Params{Struct: p}, ClientService_useConfiguration_Results{Struct: r}}
return s.UseConfiguration(call)
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
})
return methods
}
// ClientService_useConfiguration holds the arguments for a server call to ClientService.useConfiguration.
type ClientService_useConfiguration struct {
Ctx context.Context
Options capnp.CallOptions
Params ClientService_useConfiguration_Params
Results ClientService_useConfiguration_Results
}
type ClientService_useConfiguration_Params struct{ capnp.Struct }
// ClientService_useConfiguration_Params_TypeID is the unique identifier for the type ClientService_useConfiguration_Params.
const ClientService_useConfiguration_Params_TypeID = 0xb9d4ef45c2b5fc5b
func NewClientService_useConfiguration_Params(s *capnp.Segment) (ClientService_useConfiguration_Params, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return ClientService_useConfiguration_Params{st}, err
}
func NewRootClientService_useConfiguration_Params(s *capnp.Segment) (ClientService_useConfiguration_Params, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return ClientService_useConfiguration_Params{st}, err
}
func ReadRootClientService_useConfiguration_Params(msg *capnp.Message) (ClientService_useConfiguration_Params, error) {
root, err := msg.RootPtr()
return ClientService_useConfiguration_Params{root.Struct()}, err
}
func (s ClientService_useConfiguration_Params) String() string {
str, _ := text.Marshal(0xb9d4ef45c2b5fc5b, s.Struct)
return str
}
func (s ClientService_useConfiguration_Params) ClientServiceConfig() (ClientConfig, error) {
p, err := s.Struct.Ptr(0)
return ClientConfig{Struct: p.Struct()}, err
}
func (s ClientService_useConfiguration_Params) HasClientServiceConfig() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s ClientService_useConfiguration_Params) SetClientServiceConfig(v ClientConfig) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewClientServiceConfig sets the clientServiceConfig field to a newly
// allocated ClientConfig struct, preferring placement in s's segment.
func (s ClientService_useConfiguration_Params) NewClientServiceConfig() (ClientConfig, error) {
ss, err := NewClientConfig(s.Struct.Segment())
if err != nil {
return ClientConfig{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// ClientService_useConfiguration_Params_List is a list of ClientService_useConfiguration_Params.
type ClientService_useConfiguration_Params_List struct{ capnp.List }
// NewClientService_useConfiguration_Params creates a new list of ClientService_useConfiguration_Params.
func NewClientService_useConfiguration_Params_List(s *capnp.Segment, sz int32) (ClientService_useConfiguration_Params_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return ClientService_useConfiguration_Params_List{l}, err
}
func (s ClientService_useConfiguration_Params_List) At(i int) ClientService_useConfiguration_Params {
return ClientService_useConfiguration_Params{s.List.Struct(i)}
}
func (s ClientService_useConfiguration_Params_List) Set(i int, v ClientService_useConfiguration_Params) error {
return s.List.SetStruct(i, v.Struct)
}
func (s ClientService_useConfiguration_Params_List) String() string {
str, _ := text.MarshalList(0xb9d4ef45c2b5fc5b, s.List)
return str
}
// ClientService_useConfiguration_Params_Promise is a wrapper for a ClientService_useConfiguration_Params promised by a client call.
type ClientService_useConfiguration_Params_Promise struct{ *capnp.Pipeline }
func (p ClientService_useConfiguration_Params_Promise) Struct() (ClientService_useConfiguration_Params, error) {
s, err := p.Pipeline.Struct()
return ClientService_useConfiguration_Params{s}, err
}
func (p ClientService_useConfiguration_Params_Promise) ClientServiceConfig() ClientConfig_Promise {
return ClientConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
type ClientService_useConfiguration_Results struct{ capnp.Struct }
// ClientService_useConfiguration_Results_TypeID is the unique identifier for the type ClientService_useConfiguration_Results.
const ClientService_useConfiguration_Results_TypeID = 0x91f7a001ca145b9d
func NewClientService_useConfiguration_Results(s *capnp.Segment) (ClientService_useConfiguration_Results, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return ClientService_useConfiguration_Results{st}, err
}
func NewRootClientService_useConfiguration_Results(s *capnp.Segment) (ClientService_useConfiguration_Results, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return ClientService_useConfiguration_Results{st}, err
}
func ReadRootClientService_useConfiguration_Results(msg *capnp.Message) (ClientService_useConfiguration_Results, error) {
root, err := msg.RootPtr()
return ClientService_useConfiguration_Results{root.Struct()}, err
}
func (s ClientService_useConfiguration_Results) String() string {
str, _ := text.Marshal(0x91f7a001ca145b9d, s.Struct)
return str
}
func (s ClientService_useConfiguration_Results) Result() (UseConfigurationResult, error) {
p, err := s.Struct.Ptr(0)
return UseConfigurationResult{Struct: p.Struct()}, err
}
func (s ClientService_useConfiguration_Results) HasResult() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s ClientService_useConfiguration_Results) SetResult(v UseConfigurationResult) error {
return s.Struct.SetPtr(0, v.Struct.ToPtr())
}
// NewResult sets the result field to a newly
// allocated UseConfigurationResult struct, preferring placement in s's segment.
func (s ClientService_useConfiguration_Results) NewResult() (UseConfigurationResult, error) {
ss, err := NewUseConfigurationResult(s.Struct.Segment())
if err != nil {
return UseConfigurationResult{}, err
}
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
return ss, err
}
// ClientService_useConfiguration_Results_List is a list of ClientService_useConfiguration_Results.
type ClientService_useConfiguration_Results_List struct{ capnp.List }
// NewClientService_useConfiguration_Results creates a new list of ClientService_useConfiguration_Results.
func NewClientService_useConfiguration_Results_List(s *capnp.Segment, sz int32) (ClientService_useConfiguration_Results_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return ClientService_useConfiguration_Results_List{l}, err
}
func (s ClientService_useConfiguration_Results_List) At(i int) ClientService_useConfiguration_Results {
return ClientService_useConfiguration_Results{s.List.Struct(i)}
}
func (s ClientService_useConfiguration_Results_List) Set(i int, v ClientService_useConfiguration_Results) error {
return s.List.SetStruct(i, v.Struct)
}
func (s ClientService_useConfiguration_Results_List) String() string {
str, _ := text.MarshalList(0x91f7a001ca145b9d, s.List)
return str
}
// ClientService_useConfiguration_Results_Promise is a wrapper for a ClientService_useConfiguration_Results promised by a client call.
type ClientService_useConfiguration_Results_Promise struct{ *capnp.Pipeline }
func (p ClientService_useConfiguration_Results_Promise) Struct() (ClientService_useConfiguration_Results, error) {
s, err := p.Pipeline.Struct()
return ClientService_useConfiguration_Results{s}, err
}
func (p ClientService_useConfiguration_Results_Promise) Result() UseConfigurationResult_Promise {
return UseConfigurationResult_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}
const schema_db8274f9144abc7e = "x\xda\xacY}l\x1cez\x7f\x9ey\xd7\x1e;\xf1" +
"f=\xcc\"b\x13\xcb\xa7\x08t\x17\x8e\xa4\x107-" +
"q\xdb\xdb\xd8Nr\xb6/\x1f;\xfe\x08\x10\x12)\x93" +
"\xdd\xd7\xebIfg6\xf3\x91\xd8Q\xee\x02i(\xe0" +
"\x92#\xe1.\x15\xc9\x85\x13\xa4\x97\xf2\xa1\\K\xb8\xa0" +
"\xf6(\x9c\x8e\xaa\x14\xd2;\x09P\xa1\x82\x96\xfe\xd1\x83" +
"\xa8\x025\xa2p'!N\x17\xa6z\xe6\xdb\xeb\xc5!" +
"U\xffIV\xcf<\xef\xfb>\x9f\xbf\xe7\xc3\xb7\\n" +
"Y#\xdc\xdadf\x01\x94SM\xcd\xde\x1fW_;" +
"\xfd\x07\xc7\x7fq\x18\xa4N\xc1\xfb\xce\x0b\xc3\xf9\xcf\x9c" +
"C\xff\x0e\x80=\x8f6\xefG\xf9\\\xb3\x08 \xff\xb8" +
"y3\xa0\xf7/\xb7\x1cx\x7f\xc7\xaf\x8f\xdd\x0fR'" +
"&\x9c\x19\x11\xa0\xe7\xe5\xe6\x19\x94\xff\xa3Y\x04\xe6=" +
"zW\xfe\x9f\xf1\xb1O\x8f\x81\xf45\x04hB\xfa\xfc" +
"\xd3\xe6\x05\x02\xa0\xfcFs\x01\xd0{\xed\xe6\x17\x9e?" +
"\xfa\x93\xfb~\x00\xcaW\x11!8\xffq\xf3o\x11P" +
"n\x12\x89\xe1\xe3\x1f}=\xf3\xe3\xd7\xae\xf9\xa1\xcf\xe0" +
"\x9dy\xe3\xf6g\x8f\xfe\xe4+\x1f\xc2\xb8 b\x06\xa0" +
"g\xb9h\x11\xefj\xf1\xbf\x00\xbd\xef\xbf\xfd\xe2\xa6\xea" +
"\xb1\x93\xa7A\xfajtWG\x8b @\xc6[\xf5o" +
"\x177o|v\xe2\x89\xe0K G\xb6\xe5Y:\xda" +
"\xd5B\xcf\xbc\xba\xaf\xfd\xc1\xbe?|\xe8\x09P:1" +
"\xa5OS\x13q\xf6\xb5\xcc\xa0|g\x0b\xfd\x1co\xb9" +
"\x1d\x01\xbd\x99\xd5/n\xf9\xf5\x9f\xd9O\x83\xb2\x1c3" +
"\xde?>\xf0\xde\xdeeOM\xbc\xe2K\xc5\x00z." +
"\xb4\x9e\xa6\xab\xdfi\xfd\x1b@/\xfb\xf77mz\xe8" +
"\xfd\x0d\xe7\xe8\xea\x94Q\x03!\xa6\x17\xf4\xa2\xfc\xc0\x02" +
"\xb2\xeb\xbd\x0b\x88\xfb\xf5\x9b\xb7\xfc\xecg\xcfT\xce\xd5" +
"\x0b\"\x10\xf7\x8d\x0b\x87Q^\xbd\x90\xb8W-$\xee" +
"k\x87\xf0\xdd\x9f\xdf\x9a\xf9\xdbP/FL\x1f,\xfc" +
"\x90\x1e\xbf\xec3\xdc\xf5\xbb\xe7\xfea\xddGo\xfe4" +
"\xed\x80G\xdb\x04r\xc0\xb96R\xbc\xebR\x7f\xd6\xf8" +
"\xe8\xd0\xcfg\xfb1\xb8\xe9\x9d\xb6a\x94/\xb5\xd1s" +
"\x1f\xb4\xd1m\x7f\xe1\xbe\xfd\xa69<\xfcr\xbdp\xfe" +
"\xb5\xf7f\x05\x94\x8fe\x89\xfbH\xb6\x00\xf8\xe9\xd3\xf7" +
"\x1d\x1dzo\xed+J'f\xeay\x8fe\xf7\xa3|" +
"\x86x{\x1e\xcfv\x93Ec\x1b\xd6\xb1\xfbz\xbf\xb1" +
"h\x17\xca\x17\x17\xd1\xcf\xff\\\xe4\xb3\x0f\xdf\xf5\xbd\x87" +
"\x9b.~\xef\x95z\xa3\x8a\xbe\x05r\x16\xca\x97s\xf4" +
"\xf3\xb3\xdc\x13\x02\xa0\xf7\xdb\xb3\x7f\xca/\xaex\xf5\x02" +
"(_\xc1\x94\x1a\xe3(\xa2\x00\xd0s\xf1\x9a\x95d\xb2" +
"K\xd7\xec\x03\xf4:\x9f\xf9\xa3\xbf\xee/\xbf\xf3\x8b:" +
"\x8b\x90 \xf2F\xf9\x13\xf9N\x99~\x8d\xcb\xc4{\xdf" +
"\xd7\xa7\xf7o\xbaq\xe6\xad\x86\x069'\xcf\xa0|\xc1" +
"\xe7~\xd9\xe7\x16.\xaa\x1dw\xff\xeb7\xdeM\xc5\xe7" +
"\xaa\xfc\xaf\x102\xde\xa6-w\xedj\xfd\xf6{\xef\xa5" +
"\xe3sY\xde\xf7\xe3\x9f\xe4\xc9M\xe7\xa5\x87\xe5\x17\x1e" +
"\xff\xab\xf7\xe9!\xb1\xdeO\xdb\xf3[Q\xde\x93\xa7\x9f" +
"\xd5\xbc\xafo\x9c'\x8d\xa2H\xbb\xae\x17\xe5\xe9\xebH" +
".\xf7:\x92k\xd5\x8e>\xbe\xed\xb6;>\x04\xa9\x93" +
"\xcd\xca\xfa\xe7\x88\xf3e\xe2\xecy\xe9:\x11\xe5=\x8b" +
"E\x00\xef\xbb\x95\xad\x17>\x1ex\xfc\x7f\xea/\xf7\x15" +
"\xbasq/\xca\x1a\xf1\xf5\xf0\xc5\xbe\xabzn\xfd\xf3" +
"K\xc7\xffr\xe0\xe39\xb7\x9f\xeb\xe8G\xf9\xa5\x0e\x92" +
"\xe3\xc5\x8eo\xca\x97:\xfc\xcb\xbf\xb3v\xf3\xea\xa5/" +
"}\x92\xb6\xc4[\x1d\x9f\x90%>\xe8 KL\xdc\xf6" +
"\xdf\xdf\xbc\xf1\xbb\xff\xf4I\x9d{|\xc6\xd6\xce\x9bP" +
"\xee\xe8\xa4\x1b\xaf\xed,\x00~\xb4\xfe\x87ov\xe6:" +
"\x7f\xd3H\xd0\xd5\x9d\xbbP\xdeH\xbc=C\x9d\xbe\xa0" +
"w\xfc\xea\xe4\xbe\xc2\x0f~\xf3)\xe9\xc5\xea0m\xfa" +
"\xfa\xad(\x1f\xb9\x9en~\xe0zJ\x85\x0dg\xdf\xf9" +
"\xc6\xe4\xf1W?\xab7\x82\xef\x90UK\x0e\xa1<\xb4" +
"\x84\xb8\xd7-!d:\xf0\xd1\x89\xc1\x87\xb6\x9d\xfd<" +
"\xad\xd5\xf2\xae\xe7}\xffv\x91V\xbb\x8e\x1fp\x06\x1f" +
"9\xe25\x08\xba\x9e\xed]\xfd(W\xbb\xe86\xadk" +
"\x1f,\xf7\x1c\xd70\xb8n\xd52\xa5\xdf\x8b~\x96V" +
"\x94\xd4\x9aQ\xeb]7\xa5\xd9\x8efT\xc6|z\xa1" +
"h\xeaZi\xba\x88\xa8\xb4Q\xa0K]\xbd\x00\x88\xd2" +
"\xb5[\x01P\x90\xa4~\x80\x82V1L\x8b{e\xcd" +
".\x99\x86\xc1\x81\x95\x9c\x83;U]5J<~\xa8" +
"i\xeeC\x83\\\xd7\xcd\xdbMK/o\xb6\xb4\x8af" +
"\x0c\x98\xc6\x84V\x01(\"\xc6\xc7\xc4\xb9\xc7\x06t\x8d" +
"\x1b\xce(\xb7\xf6j%\xbe\xc2\xb5yp\xce\xb5TG" +
"3\x8d\x1bF\xb8\xed\xea\x8e\x0d\xa0dX\x06 \x83\x00" +
"R\xb6\x17@ia\xa8\xe4\x05,X>\x03\xb6'\x99" +
"\x07\x88\xed\x90\xbc\xd9<\xf7\xcd\xc0\x16\xf4&\xb7V\xb8" +
"\x86\xc5+\x9a\xedp+ \xdfP(\xaa\x96Z\xb5\xd3" +
"\x0f\x9e\x04P\xda\x19*K\x04\xf4*\x96Z\xe2En" +
"\xa1f\x967\xa9\x869\xcax\x09\x9b@\xc0\xa6\xd4\xa3" +
"\x0d\x1c\xb1^\xd5t^\x0e\xb4[Q\xea\xf6\xffW\xda" +
"Y\xa6\xcd\xf3\xfcG\xd4\xad\x00\xca\x0e\x86\x8a.`\x16" +
"?\xf7\xf2T\xfe$m?\x802\xc9Pq\x04\xcc\x0a" +
"\x97\xbd\xbc\xef\xb5=K\x01\x14\x9d\xa12%`\x96\xfd" +
"\xce\xcbS\x91\x91\xdc]\x00\x8a\xc3P\xb9[@\xcfv" +
"kdS\x1b\x98ia{\x12\xca\xa1ux\xb9B\x96" +
"6\xa0\xc0Kdhl\x8f\xd09`\x10\xcb\xe6$\xb6" +
"'\xc5'<f\xf1\xbd\xdc\xb2y\x11r\x9695\x8d" +
"\xed\x09J\xd7Y={\xb5V\x8f\x1c\x1d\x9f\x9a\xff\xbc" +
"\x1f\x9a%\xe7\x86b\xf7\x1cg\x91\x1d\xdb\x18*\x8b\x05" +
"\xf4j\xf4\x95;\x1c\x98ec{R\xd4\xeb\xa4m\x10" +
"\xce\x03\xf4\xef@\xf0J1\xbc\xc5\xb2\xfdpV\x16\xc7" +
"\x8f\x9d\xa0\xc7\x1ea\xa8\xfcH@\x091\xf0\xd9\xe3\x16" +
"\x80\xf2\x18C\xe5\xac\x80(\x04\x1e{\xea4\x80r\x96" +
"\xa1\xf2w\x02JL\x08\x1c\xf6\xdcM\x00\xca3\x0c\x95" +
"_\x0a(eX\x9e\x1a\x18\xe9\x02\x05\xdb/\x19*o" +
"\x0b(5e\xf2\xd8\x04 \xbd\xb5\x12@y\x9d\xa1\xf2" +
"\xae\x80\x9e\x19\xe4\x17)\xe5`\x16\x04\xcc\x02z%\xdd" +
"t\xcb\x13\xba\x0a\xdd\x16/\x0f\xad\x8d\xe9\x86[-Z" +
"|\xaf\x86\xa6k\xf79\x0e\xaf\x8a5\xc7\xc6f\x10\xb0" +
"\x190\xe7\xa8\x15\x1b\x17\x01\x16\x19b{R\xe8\x00\x89" +
"\x18\xdf\x89\x16/o\xe1\x96\xad1\xd3\xc06\x10\xb0\x0d" +
"\xb0\xdb.\x995\x8e\xedI\xed\xbc\xb2MG\xc2\xe8\xa1" +
"\xd8\x09\x13\xc1\xb44\xb1\xa2\x19J\x1b\xcb,\xf1\xbc\xd0" +
"\x80\xeb\xc8.k\x18*\x1b\x04\xec\xc2\xcf\x89L6\x1c" +
"\x1a\x01P\x06\x19*c\x02v\x09\x97\x89LVT\xc8" +
"\x07E\x86\xca6\x01s\x93\x8eS\xc3\xf6\xa4:\x86B" +
"\xed\xe3;m\xb3\xb4\x9b\x03\x12T\xc4P\x1d~\x9d\x0c" +
"\xa1\x0b\x98^\xc6\xf6\xa4\x93\xad\xd3\x885\x88\x12?@" +
"\x0a\xce:\xcb2-\x1fU\xe3\xd0X\xb72Q\"\x8a" +
"\x8c\xa1\xad\x89\x06\x92\xb0&PK\xd9\x99\xc8\xdf]R" +
"]\x9bG6\xf6,\xeeX\xd3}\x13\x0e0n\xc5\x18" +
"cO\x9a\xae^\x1e\xe1 :\xd64\"\x08\x88\xf3#" +
"\xcfZs0e\xf2 \x84Sr\x92Lk\x19*\xc5" +
"D\xce\x8dD\xdb\xc0P\xb9\x83\xe4\x0c\xcd?N\xe6\x1f" +
"c\xa8\xd4\x04\xf4t\xca]c\xd0\x04f;\xb1\xb8\x01" +
"\xb1h\xfa\x81)\x82\x80\"\xa0\xe7\xd6l\xc7\xe2j\x15" +
"0\x8e4\xe2_t\x15\x10]\x07\x15E5\xe7\xe7|" +
"c\x1d\xe24\xdc8\x9cV\"\xcc\xc3\xf1\xfe\xc4\xd8\x8d" +
"\x13i\xd2\xb4\x1dC\xadr\x00\x88\x14;h\xd6\x08#" +
"\x09A\xe26\xb3.6\xae\xbe\xb2\x05UfV];" +
"\x9d*3\xa5\xf04\xfa\xc7\x07LC\x9c\xd0*\xd8\x9e" +
"\xf4Zu\x024\xf0{\x9f\xebLr\xc3\xd1J\xfe\x83" +
"s\xfc\xbe4\x89\xcf\xd8fC+S\x86\x8cl\xb6q" +
"gbHq7\x9f\x8e!\x80WUM\x8f\xbd\x1fZ" +
"\xb3\x0f\xc4o%<\xf3%\xcf(!\x88/\x95o\x03" +
"Lu\xe5Rv%\x08\xdd{U\xdd\xe5\xf367a" +
"\x15\x0bjX!00]\x98\x8f\xd5\xfc\xf6\x0c\x80r" +
"7C\xe5\xc1\x94\x9a\x0f<\x0c\xa0<\xc8Py$\xa5" +
"\xe6q\x0a\x8d\xa3\x0c\x95S\x04\xd1,\x00\x97\x13\xe4\x93" +
"S\x0c\x95'\x05\xc4L\x80\xd0g\x08\xa1\x9fd\xa8\x9c" +
"\x17||\x1d\xec\x1b0\x0d\x0c\x85\xb0\x01\"t\xf5&" +
"\xb9j9;\xb9\x8a\xce\x90\xe1pk\xaf\x8az\x94\xc5" +
"\x07\x1d\xad\xcaM\xd7\x89\xb3\xba\xaaN\xf9\x1d\x02\x96\x07" +
"\x83S\xa2\xea\xd8\xd8\x0a\x02\xb6R\x12\xd9\xdc\x1a\xb0x" +
"\x19\xc9\x9f\xaa^T\x9939\xc7\xc4\x99+!n\xae" +
"\x81y\xa8\xbf8\xc0P\xb9\x9f\xb2\x1fS\x83\xacto" +
"/\x08~\xf2\x93\xce\xd5\xfe\xa4\x0f\xf1\xeb\x17U\xa5=" +
"\x0f'\x0d\x87_\xbf\x9a\xe9\xc6\x93\x89\xc1C\xd1\x06M" +
"(\x04I\x15\xc9\\\x08\x82\xe5 \x01\x9c\xc6\x13=\xc3" +
"\xb2\xae\xa1i\x8c\xf9\x06\xc2\xc4B%\xb3Z\xb3\xb8m" +
"\xa3f\x1a\x8a\xab\xea\x1as\xa6\xe3\x83\xf3\xda\x80\xd0#" +
"\xc8\xba\xcd\xb5n\xdfId\x84[\"#\xc8}8\x0c" +
"0\xba\x06\x19\x8en\xc0$L\xe4!\xec\x07\x18]K" +
"\xf4\"&\x91\"o\xc4N\x80\xd1A\xa2\x8f\xa1\x80\x18" +
"\xc4\x8a\xac\xe0\xd3\x00\xa3cD\xde\x81IE\x97\xb7\xfb" +
"\xd7o#\xfa$&E]\xe6x\x13\xc0\xe8\x0e\xa2\x1f" +
" z\xb3\xe0[P\x9e\xc6]\x00\xa3SD?Lt" +
"\xb1)O\xf3\x81|\x0fZ\x00\xa3w\x13\xfdA\xa2\xb7" +
",\xcec\x0b\xcd\x1f>\xfd~\xa2\x7f\x9f\xe8\xad\x1dy" +
"l\x05\x90\x8f\xe1!\x80\xd1\xa3D?E\xf4\x05\x98\xc7" +
"\x05\x00\xf2\x09<\x090z\x8a\xe8O\x12}as\x1e" +
"\x17\x02\xc8g|y\x1e#\xfaY\x8c!h\xa8\x9cF" +
"B\x0a'-\xe9\x02\x98i\xc7a\xc8\xc3I\x03\x03\x98" +
".\x9a9\x1a50\x97\xec\x90\x001\x07\xe8\xd5LS" +
"\xdf4\x1ba\xaf\xd4\x88\x84a\x019\xd3\x18*\xc7\xf9" +
"\x15\x04\xd1\x06\x13\xbaK\xaa>T\x8b%\xd1\xec>\xd7" +
"1\xdd\x1at\x97U\x87\x97\xe3\x1ai\xb9\xc6z\xcb\xac" +
"\x8e!\xb7\xaa\x9a\xa1\xea\x10\x7f\x99/\xb6r\xae\xab\x95" +
"\xbf4\x9e\xad\x08PKiI:\xfbeT\x9d\xbe\xc6" +
"P\xf9\xfdtg\x7f+A\xed\xcd\x0c\x95\xdb\xa8[\x9f" +
"\xb6\x1d^\xdd\xa4\x02Kr\xa4\xbbb\x99nm\xce\xc3" +
"B\xfd\xc3\xdd\xb5\xde1\xd5O\xeb\x968\xad\x97Q\x07" +
"u\x03C\xe5\x96\x14\xea-_\x99\xc8\x91Kgc " +
"\xf2\x9c\x97\x1atp\xe3uU,\xe8\xda\x83\xd2\x92z" +
"\xbd?y=~\xdc\x0a\xd5\x1d\x14\xf0\xa0\xed\x96Jd" +
"\xed\xc8\xfc\x13\xe1l\x04\xddtw*\x10\xe2\xb5E\x18" +
"\x08_\xb6c\xa8p'\xf85dL\x98TjE\xb5" +
"j\xff\x1fO\x8fp;G\xa3\xc9\x15'\xd0x\x11q" +
"\xe5\xd2<86VL\xc6d\x16\xa0r\x1a\x90F\xd2" +
"\x80\x94\xe0\xd1\xae4\xeeD\x1d\xa4\xac\xf8\x00P$\xfa" +
"6L\xe6\x0b\xf9N<=\x0bx2}\x01 q\xff" +
"\xfa2\xd1k> a\x00HU\xff~\x9d\xe8Si" +
"@rqf6 \xb1\x08\x90\x08H\x0e\x13\xfd\xa8\x0f" +
"H\x99\x00\x90\x8e\xe0\xb3\xb3\x80\xa7\xb5)\x00\xa4\x13\xf8" +
"\xfc,\xe0Y\xd0\x1c\x00\xd2\x19\x9f\xffI\xa2\x9f\xf7\x01" +
"\xa9?\x00\xa4s>\x80=C\xf4\x17\x08\x90\\K\x1f" +
"u,\xcd\x00\xac$\xc1Z\xaa}\x8b\xf3Z\x1f\xe4t" +
"m/\x8f\x8bEYS\xf5\xb5\xae\xaaC\xf7\xa8\xa3\x96" +
"v'm\xb2n\x0f\xaaF\xd9\xc6Iu7\xa7\x12#" +
"\xa6\x8b\xb0\xa3\xdb[\xb8\xa5M\x00&\x8du\xdc\xd6\xe4" +
"\x8a\xa6Y\xdf\xed\xf8\xfd\x19\xb7\x024\x8b\xbfU\xd5\xa9" +
"\xa1\xb2\xce\x070jM\x98\x91\x948\x8d\xbe\x98\x86\x81" +
"A\xbf0\xa6u\xcfn\x04ja\xab\x1e5\x14c\x85" +
"\xbaN\x81O\xd5x\xc9\x190\xd1p4\xc3\xe5s." +
"(M\xba\xc6n^^\x87F\xc9,kF\x05\xe6\xcc" +
"\x08\xec\x8b\xb6\x13\xa9\x0e\xaa%l\xc9\xe2u\xbb\xb4\x8c" +
"\xfa\x01\x0c\xfb\x01\xa97\x99\xb2\x0b%\xffT\xc1\xe2\xaa" +
"\x9d\x94\x86\xf9^\x0b\x97QA\x92\xd1k\xed\xac\x09 " +
"^^c\xb4\xf3\x93\xf6\xec\x07A\xd2DLV\xa5\x18" +
"mF\xa5\xed\x16\x08\xd2\xb8\x88B\xfc7\x03\x8c\xf6\xfd" +
"\xd2\xd0\x0c\x08\xd2:\x11Y\xbc\xe8\xc7h\xe3&\xad\xee" +
"\x07AZ.z\xd1T\x01\x85@\x9c5\xe8E\x89\x0f" +
"\xdd~\xea\xafA/\xdaS`4}\x00\xac\xc1\x83a" +
"=Z\x83\xe9\xe5\x16\xfb\xa2\x11\xa0q_J\x189\xc5" +
"P9\x9c`\xe4=\xd4\xab\x1ef\xa8\x1cM\x8d]G" +
"\x9eN\xb7\xa5\xe1\xe6\xe0\xc4\xa1p\xefp>\xb598" +
"G\xbd\xeay\x86\xca\xebBR\xa8\xa3\xb0\x8b\xf6Ah" +
"Z\xd1\x1c8\xcfZ(\x0c\xce\xb0e\xac_\x0eye" +
"s\xd2o)1\xb8\xca\x86\x04\xb1\xd3\x1b\xa3E\xa9\x8d" +
"\x11F\x13\xa88\x0b\xe0\xd3\xfb\xa3E\xf3c\xe6\xacy" +
"*\x1c\x1b(j\xa2\xbfh`\xf4\xb7%I\"\xefg" +
"E/\x9a\xb90*W\xe4\xbc\xb4\xcb\xaer\xf0\x1c\xe1" +
"\xdd\xf6\x97\xa9\x04\xd1\x96\xf9\xca\xfb\x83\xe0\x9d\x1c\x05[" +
"<\x07\x05\xf7\xeeJm\xb1t3\x1c\xe1r\x9bRU" +
"{>[\x05\x02G\x9do\x8e\x0e\xd7\x85\xdf\xd2$\xfc" +
"\xe2\x06\xe1\x9e\xa5\xc90\x10\x8fE\xf7\x0e\x87A\xf9X" +
"\xdc\xe9J\x8f\xce$\x1b\xae8\xfc\x9e\x1aN\xc6\"\x91" +
"[V$\xa7\xe8Z\x09l\xeafe\x83fp\x9bz" +
"\xbf\xbam@\x8d[U\xd5\xe0\x06:\x04F\xaeE\x88" +
":\x1b\xb9\x86\xd6\xa6Z\xc6\xf9\xd4\x1f\x0d\x83=\x88\xf5" +
"\xb0\xbc\xa6F\xdf\xd3\xa95L\xa4\xbc\xf2|\xb8\xde\xd8" +
"\x91R~;\x8d\xbe\xdb\x18*\x93\x02z\xaa\xeb\x98\xe3" +
"\xb5\xb2\x8a\x0e_o\xf1=.\x17\x8d\xd2t2\xc0\xd1" +
"(S\xb2\xc7\xb1FM\xe7z\x8b\x17\xf6\xb8<\xcd\x10" +
"-\x8eA\xd4\xcc\xf2\x9c\x8dq\x83f\xebv\xbes\xd4" +
",\xed\xe6\xce\xac\x85z\x00\x97\x91*\xeaH\xb25\x8e" +
"4\xd1FR\xb3Z\x04#{(\xa0j\x0c\x95\x03)" +
"\x18\x99\x9eI\x1c\xde\xb8\xba\xfe\xff\x14\xc4y\x94l\xb8" +
"\xd5\x1d)\xf0/\x95h\xc9_I\xae\xdcr\x85{\x82" +
"\xb0c\xadkX\x976j\x97\xb7&\x0d\xba\x1f\xcf\xed" +
"\xc9_n\xc3\xe7\xec\xb0K\x046a\xcem\x00\xff7" +
"\x00\x00\xff\xff\xfd\xa0l\x0d"
func init() {
schemas.Register(schema_db8274f9144abc7e,
0x84cb9536a2cf6d3c,
0x8891f360e47c30d3,
0x91f7a001ca145b9d,
0x9b87b390babc2ccf,
0x9e12cfad042ba4f1,
0xa29a916d4ebdd894,
0xa766b24d4fe5da35,
0xa78f37418c1077c8,
0xaa7386f356bd398a,
0xb14ce48f4e2abb0d,
0xb167b0bebe562cd0,
0xb70431c0dc014915,
0xb9d4ef45c2b5fc5b,
0xc082ef6e0d42ed1d,
0xc54a4a6fd4d87596,
0xc744e349009087aa,
0xc766a92976e389c4,
0xc793e50592935b4a,
0xc9c82ee56583acfa,
0xcbd96442ae3bb01a,
0xd58a254e7a792b87,
0xdc3ed6801961e502,
0xe3e37d096a5b564e,
0xe4a6a1bc139211b4,
0xea20b390b257d1a5,
0xea58385c65416035,
0xf0a143f1c95a678e,
0xf143a395ed8b3133,
0xf2c122394f447e8e,
0xf2c68e2547ec3866,
0xf41a0f001ad49e46,
0xf7f49b3f779ae258,
0xf9c895683ed9ac4c,
0xfeac5c8f4899ef7c,
0xff8d9848747c956a)
}
Reference in New Issue View Git Blame Copy Permalink