3833 lines
126 KiB
Go
3833 lines
126 KiB
Go
// 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: 6})
|
|
return CapnpConnectParameters{st}, err
|
|
}
|
|
|
|
func NewRootCapnpConnectParameters(s *capnp.Segment) (CapnpConnectParameters, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 6})
|
|
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) Name() (string, error) {
|
|
p, err := s.Struct.Ptr(4)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s CapnpConnectParameters) HasName() bool {
|
|
p, err := s.Struct.Ptr(4)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s CapnpConnectParameters) NameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(4)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s CapnpConnectParameters) SetName(v string) error {
|
|
return s.Struct.SetText(4, v)
|
|
}
|
|
|
|
func (s CapnpConnectParameters) Group() (string, error) {
|
|
p, err := s.Struct.Ptr(5)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s CapnpConnectParameters) HasGroup() bool {
|
|
p, err := s.Struct.Ptr(5)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s CapnpConnectParameters) GroupBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(5)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s CapnpConnectParameters) SetGroup(v string) error {
|
|
return s.Struct.SetText(5, v)
|
|
}
|
|
|
|
// CapnpConnectParameters_List is a list of CapnpConnectParameters.
|
|
type CapnpConnectParameters_List struct{ capnp.List }
|
|
|
|
// NewCapnpConnectParameters creates a new list of CapnpConnectParameters.
|
|
func NewCapnpConnectParameters_List(s *capnp.Segment, sz int32) (CapnpConnectParameters_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 6}, sz)
|
|
return CapnpConnectParameters_List{l}, err
|
|
}
|
|
|
|
func (s CapnpConnectParameters_List) At(i int) CapnpConnectParameters {
|
|
return CapnpConnectParameters{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s CapnpConnectParameters_List) Set(i int, v CapnpConnectParameters) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s CapnpConnectParameters_List) String() string {
|
|
str, _ := text.MarshalList(0xa78f37418c1077c8, s.List)
|
|
return str
|
|
}
|
|
|
|
// CapnpConnectParameters_Promise is a wrapper for a CapnpConnectParameters promised by a client call.
|
|
type CapnpConnectParameters_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p CapnpConnectParameters_Promise) Struct() (CapnpConnectParameters, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return CapnpConnectParameters{s}, err
|
|
}
|
|
|
|
type ConnectResult struct{ capnp.Struct }
|
|
|
|
// ConnectResult_TypeID is the unique identifier for the type ConnectResult.
|
|
const ConnectResult_TypeID = 0xff8d9848747c956a
|
|
|
|
func NewConnectResult(s *capnp.Segment) (ConnectResult, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return ConnectResult{st}, err
|
|
}
|
|
|
|
func NewRootConnectResult(s *capnp.Segment) (ConnectResult, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return ConnectResult{st}, err
|
|
}
|
|
|
|
func ReadRootConnectResult(msg *capnp.Message) (ConnectResult, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConnectResult{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectResult) String() string {
|
|
str, _ := text.Marshal(0xff8d9848747c956a, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConnectResult) Err() (ConnectError, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return ConnectError{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectResult) HasErr() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectResult) SetErr(v ConnectError) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewErr sets the err field to a newly
|
|
// allocated ConnectError struct, preferring placement in s's segment.
|
|
func (s ConnectResult) NewErr() (ConnectError, error) {
|
|
ss, err := NewConnectError(s.Struct.Segment())
|
|
if err != nil {
|
|
return ConnectError{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ConnectResult) ServerInfo() (ServerInfo, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return ServerInfo{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectResult) HasServerInfo() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectResult) SetServerInfo(v ServerInfo) error {
|
|
return s.Struct.SetPtr(1, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewServerInfo sets the serverInfo field to a newly
|
|
// allocated ServerInfo struct, preferring placement in s's segment.
|
|
func (s ConnectResult) NewServerInfo() (ServerInfo, error) {
|
|
ss, err := NewServerInfo(s.Struct.Segment())
|
|
if err != nil {
|
|
return ServerInfo{}, err
|
|
}
|
|
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ConnectResult) ClientConfig() (ClientConfig, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return ClientConfig{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectResult) HasClientConfig() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectResult) SetClientConfig(v ClientConfig) error {
|
|
return s.Struct.SetPtr(2, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewClientConfig sets the clientConfig field to a newly
|
|
// allocated ClientConfig struct, preferring placement in s's segment.
|
|
func (s ConnectResult) NewClientConfig() (ClientConfig, error) {
|
|
ss, err := NewClientConfig(s.Struct.Segment())
|
|
if err != nil {
|
|
return ClientConfig{}, err
|
|
}
|
|
err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// ConnectResult_List is a list of ConnectResult.
|
|
type ConnectResult_List struct{ capnp.List }
|
|
|
|
// NewConnectResult creates a new list of ConnectResult.
|
|
func NewConnectResult_List(s *capnp.Segment, sz int32) (ConnectResult_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
|
|
return ConnectResult_List{l}, err
|
|
}
|
|
|
|
func (s ConnectResult_List) At(i int) ConnectResult { return ConnectResult{s.List.Struct(i)} }
|
|
|
|
func (s ConnectResult_List) Set(i int, v ConnectResult) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
func (s ConnectResult_List) String() string {
|
|
str, _ := text.MarshalList(0xff8d9848747c956a, s.List)
|
|
return str
|
|
}
|
|
|
|
// ConnectResult_Promise is a wrapper for a ConnectResult promised by a client call.
|
|
type ConnectResult_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConnectResult_Promise) Struct() (ConnectResult, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConnectResult{s}, err
|
|
}
|
|
|
|
func (p ConnectResult_Promise) Err() ConnectError_Promise {
|
|
return ConnectError_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
func (p ConnectResult_Promise) ServerInfo() ServerInfo_Promise {
|
|
return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
|
|
}
|
|
|
|
func (p ConnectResult_Promise) ClientConfig() ClientConfig_Promise {
|
|
return ClientConfig_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
|
|
}
|
|
|
|
type ConnectError struct{ capnp.Struct }
|
|
|
|
// ConnectError_TypeID is the unique identifier for the type ConnectError.
|
|
const ConnectError_TypeID = 0xb14ce48f4e2abb0d
|
|
|
|
func NewConnectError(s *capnp.Segment) (ConnectError, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
|
|
return ConnectError{st}, err
|
|
}
|
|
|
|
func NewRootConnectError(s *capnp.Segment) (ConnectError, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
|
|
return ConnectError{st}, err
|
|
}
|
|
|
|
func ReadRootConnectError(msg *capnp.Message) (ConnectError, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConnectError{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectError) String() string {
|
|
str, _ := text.Marshal(0xb14ce48f4e2abb0d, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConnectError) Cause() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s ConnectError) HasCause() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectError) CauseBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s ConnectError) SetCause(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s ConnectError) RetryAfter() int64 {
|
|
return int64(s.Struct.Uint64(0))
|
|
}
|
|
|
|
func (s ConnectError) SetRetryAfter(v int64) {
|
|
s.Struct.SetUint64(0, uint64(v))
|
|
}
|
|
|
|
func (s ConnectError) ShouldRetry() bool {
|
|
return s.Struct.Bit(64)
|
|
}
|
|
|
|
func (s ConnectError) SetShouldRetry(v bool) {
|
|
s.Struct.SetBit(64, v)
|
|
}
|
|
|
|
// ConnectError_List is a list of ConnectError.
|
|
type ConnectError_List struct{ capnp.List }
|
|
|
|
// NewConnectError creates a new list of ConnectError.
|
|
func NewConnectError_List(s *capnp.Segment, sz int32) (ConnectError_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}, sz)
|
|
return ConnectError_List{l}, err
|
|
}
|
|
|
|
func (s ConnectError_List) At(i int) ConnectError { return ConnectError{s.List.Struct(i)} }
|
|
|
|
func (s ConnectError_List) Set(i int, v ConnectError) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
func (s ConnectError_List) String() string {
|
|
str, _ := text.MarshalList(0xb14ce48f4e2abb0d, s.List)
|
|
return str
|
|
}
|
|
|
|
// ConnectError_Promise is a wrapper for a ConnectError promised by a client call.
|
|
type ConnectError_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConnectError_Promise) Struct() (ConnectError, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConnectError{s}, err
|
|
}
|
|
|
|
type ClientConfig struct{ capnp.Struct }
|
|
|
|
// ClientConfig_TypeID is the unique identifier for the type ClientConfig.
|
|
const ClientConfig_TypeID = 0xf0a143f1c95a678e
|
|
|
|
func NewClientConfig(s *capnp.Segment) (ClientConfig, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
|
|
return ClientConfig{st}, err
|
|
}
|
|
|
|
func NewRootClientConfig(s *capnp.Segment) (ClientConfig, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
|
|
return ClientConfig{st}, err
|
|
}
|
|
|
|
func ReadRootClientConfig(msg *capnp.Message) (ClientConfig, error) {
|
|
root, err := msg.RootPtr()
|
|
return ClientConfig{root.Struct()}, err
|
|
}
|
|
|
|
func (s ClientConfig) String() string {
|
|
str, _ := text.Marshal(0xf0a143f1c95a678e, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ClientConfig) Version() uint64 {
|
|
return s.Struct.Uint64(0)
|
|
}
|
|
|
|
func (s ClientConfig) SetVersion(v uint64) {
|
|
s.Struct.SetUint64(0, v)
|
|
}
|
|
|
|
func (s ClientConfig) SupervisorConfig() (SupervisorConfig, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return SupervisorConfig{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ClientConfig) HasSupervisorConfig() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ClientConfig) SetSupervisorConfig(v SupervisorConfig) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewSupervisorConfig sets the supervisorConfig field to a newly
|
|
// allocated SupervisorConfig struct, preferring placement in s's segment.
|
|
func (s ClientConfig) NewSupervisorConfig() (SupervisorConfig, error) {
|
|
ss, err := NewSupervisorConfig(s.Struct.Segment())
|
|
if err != nil {
|
|
return SupervisorConfig{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ClientConfig) EdgeConnectionConfig() (EdgeConnectionConfig, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return EdgeConnectionConfig{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ClientConfig) HasEdgeConnectionConfig() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ClientConfig) SetEdgeConnectionConfig(v EdgeConnectionConfig) error {
|
|
return s.Struct.SetPtr(1, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewEdgeConnectionConfig sets the edgeConnectionConfig field to a newly
|
|
// allocated EdgeConnectionConfig struct, preferring placement in s's segment.
|
|
func (s ClientConfig) NewEdgeConnectionConfig() (EdgeConnectionConfig, error) {
|
|
ss, err := NewEdgeConnectionConfig(s.Struct.Segment())
|
|
if err != nil {
|
|
return EdgeConnectionConfig{}, err
|
|
}
|
|
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ClientConfig) DohProxyConfigs() (DoHProxyConfig_List, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return DoHProxyConfig_List{List: p.List()}, err
|
|
}
|
|
|
|
func (s ClientConfig) HasDohProxyConfigs() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ClientConfig) SetDohProxyConfigs(v DoHProxyConfig_List) error {
|
|
return s.Struct.SetPtr(2, v.List.ToPtr())
|
|
}
|
|
|
|
// NewDohProxyConfigs sets the dohProxyConfigs field to a newly
|
|
// allocated DoHProxyConfig_List, preferring placement in s's segment.
|
|
func (s ClientConfig) NewDohProxyConfigs(n int32) (DoHProxyConfig_List, error) {
|
|
l, err := NewDoHProxyConfig_List(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return DoHProxyConfig_List{}, err
|
|
}
|
|
err = s.Struct.SetPtr(2, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
func (s ClientConfig) ReverseProxyConfigs() (ReverseProxyConfig_List, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return ReverseProxyConfig_List{List: p.List()}, err
|
|
}
|
|
|
|
func (s ClientConfig) HasReverseProxyConfigs() bool {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ClientConfig) SetReverseProxyConfigs(v ReverseProxyConfig_List) error {
|
|
return s.Struct.SetPtr(3, v.List.ToPtr())
|
|
}
|
|
|
|
// NewReverseProxyConfigs sets the reverseProxyConfigs field to a newly
|
|
// allocated ReverseProxyConfig_List, preferring placement in s's segment.
|
|
func (s ClientConfig) NewReverseProxyConfigs(n int32) (ReverseProxyConfig_List, error) {
|
|
l, err := NewReverseProxyConfig_List(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return ReverseProxyConfig_List{}, err
|
|
}
|
|
err = s.Struct.SetPtr(3, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
// ClientConfig_List is a list of ClientConfig.
|
|
type ClientConfig_List struct{ capnp.List }
|
|
|
|
// NewClientConfig creates a new list of ClientConfig.
|
|
func NewClientConfig_List(s *capnp.Segment, sz int32) (ClientConfig_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}, sz)
|
|
return ClientConfig_List{l}, err
|
|
}
|
|
|
|
func (s ClientConfig_List) At(i int) ClientConfig { return ClientConfig{s.List.Struct(i)} }
|
|
|
|
func (s ClientConfig_List) Set(i int, v ClientConfig) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
func (s ClientConfig_List) String() string {
|
|
str, _ := text.MarshalList(0xf0a143f1c95a678e, s.List)
|
|
return str
|
|
}
|
|
|
|
// ClientConfig_Promise is a wrapper for a ClientConfig promised by a client call.
|
|
type ClientConfig_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ClientConfig_Promise) Struct() (ClientConfig, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ClientConfig{s}, err
|
|
}
|
|
|
|
func (p ClientConfig_Promise) SupervisorConfig() SupervisorConfig_Promise {
|
|
return SupervisorConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
func (p ClientConfig_Promise) EdgeConnectionConfig() EdgeConnectionConfig_Promise {
|
|
return EdgeConnectionConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
|
|
}
|
|
|
|
type SupervisorConfig struct{ capnp.Struct }
|
|
|
|
// SupervisorConfig_TypeID is the unique identifier for the type SupervisorConfig.
|
|
const SupervisorConfig_TypeID = 0xf7f49b3f779ae258
|
|
|
|
func NewSupervisorConfig(s *capnp.Segment) (SupervisorConfig, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0})
|
|
return SupervisorConfig{st}, err
|
|
}
|
|
|
|
func NewRootSupervisorConfig(s *capnp.Segment) (SupervisorConfig, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0})
|
|
return SupervisorConfig{st}, err
|
|
}
|
|
|
|
func ReadRootSupervisorConfig(msg *capnp.Message) (SupervisorConfig, error) {
|
|
root, err := msg.RootPtr()
|
|
return SupervisorConfig{root.Struct()}, err
|
|
}
|
|
|
|
func (s SupervisorConfig) String() string {
|
|
str, _ := text.Marshal(0xf7f49b3f779ae258, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s SupervisorConfig) AutoUpdateFrequency() int64 {
|
|
return int64(s.Struct.Uint64(0))
|
|
}
|
|
|
|
func (s SupervisorConfig) SetAutoUpdateFrequency(v int64) {
|
|
s.Struct.SetUint64(0, uint64(v))
|
|
}
|
|
|
|
func (s SupervisorConfig) MetricsUpdateFrequency() int64 {
|
|
return int64(s.Struct.Uint64(8))
|
|
}
|
|
|
|
func (s SupervisorConfig) SetMetricsUpdateFrequency(v int64) {
|
|
s.Struct.SetUint64(8, uint64(v))
|
|
}
|
|
|
|
func (s SupervisorConfig) GracePeriod() int64 {
|
|
return int64(s.Struct.Uint64(16))
|
|
}
|
|
|
|
func (s SupervisorConfig) SetGracePeriod(v int64) {
|
|
s.Struct.SetUint64(16, uint64(v))
|
|
}
|
|
|
|
// SupervisorConfig_List is a list of SupervisorConfig.
|
|
type SupervisorConfig_List struct{ capnp.List }
|
|
|
|
// NewSupervisorConfig creates a new list of SupervisorConfig.
|
|
func NewSupervisorConfig_List(s *capnp.Segment, sz int32) (SupervisorConfig_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0}, sz)
|
|
return SupervisorConfig_List{l}, err
|
|
}
|
|
|
|
func (s SupervisorConfig_List) At(i int) SupervisorConfig { return SupervisorConfig{s.List.Struct(i)} }
|
|
|
|
func (s SupervisorConfig_List) Set(i int, v SupervisorConfig) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s SupervisorConfig_List) String() string {
|
|
str, _ := text.MarshalList(0xf7f49b3f779ae258, s.List)
|
|
return str
|
|
}
|
|
|
|
// SupervisorConfig_Promise is a wrapper for a SupervisorConfig promised by a client call.
|
|
type SupervisorConfig_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p SupervisorConfig_Promise) Struct() (SupervisorConfig, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return SupervisorConfig{s}, err
|
|
}
|
|
|
|
type EdgeConnectionConfig struct{ capnp.Struct }
|
|
|
|
// EdgeConnectionConfig_TypeID is the unique identifier for the type EdgeConnectionConfig.
|
|
const EdgeConnectionConfig_TypeID = 0xc744e349009087aa
|
|
|
|
func NewEdgeConnectionConfig(s *capnp.Segment) (EdgeConnectionConfig, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1})
|
|
return EdgeConnectionConfig{st}, err
|
|
}
|
|
|
|
func NewRootEdgeConnectionConfig(s *capnp.Segment) (EdgeConnectionConfig, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1})
|
|
return EdgeConnectionConfig{st}, err
|
|
}
|
|
|
|
func ReadRootEdgeConnectionConfig(msg *capnp.Message) (EdgeConnectionConfig, error) {
|
|
root, err := msg.RootPtr()
|
|
return EdgeConnectionConfig{root.Struct()}, err
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) String() string {
|
|
str, _ := text.Marshal(0xc744e349009087aa, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) NumHAConnections() uint8 {
|
|
return s.Struct.Uint8(0)
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) SetNumHAConnections(v uint8) {
|
|
s.Struct.SetUint8(0, v)
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) HeartbeatInterval() int64 {
|
|
return int64(s.Struct.Uint64(8))
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) SetHeartbeatInterval(v int64) {
|
|
s.Struct.SetUint64(8, uint64(v))
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) Timeout() int64 {
|
|
return int64(s.Struct.Uint64(16))
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) SetTimeout(v int64) {
|
|
s.Struct.SetUint64(16, uint64(v))
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) MaxFailedHeartbeats() uint64 {
|
|
return s.Struct.Uint64(24)
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) SetMaxFailedHeartbeats(v uint64) {
|
|
s.Struct.SetUint64(24, v)
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) UserCredentialPath() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) HasUserCredentialPath() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) UserCredentialPathBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s EdgeConnectionConfig) SetUserCredentialPath(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
// EdgeConnectionConfig_List is a list of EdgeConnectionConfig.
|
|
type EdgeConnectionConfig_List struct{ capnp.List }
|
|
|
|
// NewEdgeConnectionConfig creates a new list of EdgeConnectionConfig.
|
|
func NewEdgeConnectionConfig_List(s *capnp.Segment, sz int32) (EdgeConnectionConfig_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1}, sz)
|
|
return EdgeConnectionConfig_List{l}, err
|
|
}
|
|
|
|
func (s EdgeConnectionConfig_List) At(i int) EdgeConnectionConfig {
|
|
return EdgeConnectionConfig{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s EdgeConnectionConfig_List) Set(i int, v EdgeConnectionConfig) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s EdgeConnectionConfig_List) String() string {
|
|
str, _ := text.MarshalList(0xc744e349009087aa, s.List)
|
|
return str
|
|
}
|
|
|
|
// EdgeConnectionConfig_Promise is a wrapper for a EdgeConnectionConfig promised by a client call.
|
|
type EdgeConnectionConfig_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p EdgeConnectionConfig_Promise) Struct() (EdgeConnectionConfig, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return EdgeConnectionConfig{s}, err
|
|
}
|
|
|
|
type ReverseProxyConfig struct{ capnp.Struct }
|
|
type ReverseProxyConfig_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{p\\\xe5u?\xe7~\xab\xbd\x96-" +
|
|
"y\xf7r\x15\x88\x84=j<0\x09\x04S\x8cK\x1b" +
|
|
"\xd4N\xd6\x92,Gr\xfc\xd8O+\x1b0\xf6\x8c\xaf" +
|
|
"w?\xad\xae}\xf7\xde\xf5}\x18\xc9cb\xf0\x98\x02" +
|
|
"*\x04C\xf0\x0cv C\xdc\xba<\x06\xca#0\x1d" +
|
|
"\xa8\x9d\x92N)\xd0\x94!L\xa0S\xb7\xc9\x1f\x04<" +
|
|
"\x0dL2\x04B\x87\xd2\x01n\xe7\xdc\xb7VB\xb6;" +
|
|
"\xfd\x07\xae\xcf\x9e\xef\xfb\xce\xf3w\x1e\xba\xe2\xe7\x0bV" +
|
|
"I+\xda\xfe\xbe\x03\x80\xdf\xdb\x96\xf7\xff\xac\xf1\xda\xb1" +
|
|
"?>\xfc\xd3\x83\xa0\xf4H\xfewN\xac\xed\xfa\xc4=" +
|
|
"\xf0\x1f\x00\xb8r(\xbf\x17\xd5\xeb\xf22\x80\xba)\xbf" +
|
|
"\x11\xd0\xff\xf9\x15\xfb\xde\xd9\xfe\xfb\xbbo\x03\xa5\x07S" +
|
|
"\xce\x9c\x0c\xb0\xb2\x91\x9fF\xf5\x96\xbc\x0c\xcc\x7f\xe0\xfa" +
|
|
"\xae\x7f\xc6\x07?\xbe\x1b\x94\xaf!@\x1b\xd2\xcfZ~" +
|
|
"\xa1\x04\xa8N\xe5K\x80\xfek\x97\x9dx\xfe\xd0\x8fn" +
|
|
"\xfd>\xf0\xaf\"Bx\xfeH\xfe\x7f\x10P}<`" +
|
|
"\xf8\xe0\xaf\xbe\x9e{\xfc\xb5\xf3~\x100\xf8\xc7_\xbf" +
|
|
"\xe6\xe9C?\xfa\x83\xf7`\x93$c\x0e`\xe5\x9by" +
|
|
"\x9bx\xdf\xca\xff'\xa0\x7f\xef\xbf\x9d\xdc\xd0\xb8\xfb\xe8" +
|
|
"1P\xbe\x1a\xdf\xf5\x13Y\x92 \xe7_\xf5\xef\xa77" +
|
|
"\xae\x7fz\xfc\xa1\xf0\x97P\x8eg\xe5\xa7\xe9\xe8\x8b2" +
|
|
"=\xf3\xf2\x0d\xc5;\xfa\xff\xe4\xae\x87\x80\xf7`F\x9f" +
|
|
"6\xd2x\xe5\xbb\xf24\xaa\xb8\x80>?\x93\xefB@" +
|
|
"\x7f\xfa\xea\x93\x9b\x7f\xff\xe7\xce\xa3\xc0\x97c\xce\xff\xc7" +
|
|
"\xdb\xdf\xdes\xc9#\xe3/\x05R1\x80\x95\x8f\xb7\x1f" +
|
|
"\xa3\xabO\xb6?\x01\xe8w\xfe\xdd\xa5\x1b\xeezg\xdd" +
|
|
"Stu\xc6\xa8\xa1\x10\xdb\x16\xf6\xa1\xdaXHv\xd5" +
|
|
"\x17\x12\xf7\xcf.\xdb\xfc\xe3\x1f?Y\x7f\xaaU\x10\x89" +
|
|
"\xb8\xdb\x17\xadEu\xe9\"\xe2\xee^D\xdc_\x1a\xc1" +
|
|
"_\xbc\xb0\"\xf7\xb7\x91^\x8c\x98^]\xf4^`\x92" +
|
|
"\x80\xe1\xfaO\x9f\xfd\x87\xa1\xf7\xdfx.\xeb\x80\x9b;" +
|
|
"$r\xc0\xe1\x0eR|\xe9o\x07:\xcd\xf7\x0f\xbc0" +
|
|
"\xd3\x8f\xe1M';\xd6\xa2\xfaz\x07=\xf7j\xc7\x13" +
|
|
"\x80\x1f?z\xeb\xa1\x91\xb7W\xbf\xc4{0\xd7\xaa\x88" +
|
|
"\xde\xb9\x17\xd5\x1b;\xe9s\xaa\xb3\x97l\x94X\xa5\x85" +
|
|
"=\xd0\xe4\x91\xc5;Q=\xb9\x98>\x9f[\x1c\xb0\xaf" +
|
|
"\xbd\xfe{\xf7\xb4\x9d\xfe\xdeK\xadf\x92\x037\x16l" +
|
|
"T\xdf,\xd0\xe7\xeb\x85\x87$@\xbf\xe7\xc9?\xfd\x9b" +
|
|
"\x81\xda\xa9\x9f\xb6\xc8M\x97\xab'\xcf\xfbP}\xe5<" +
|
|
"\xfaz\xf1\xbc\x1b\x00\xfd[\xbf>\xb5w\xc3\xc5\xd3o" +
|
|
"\xb6\xda4\x10\xfc+\xea4\xaaW\xab\xc4}\x95J\xdc" +
|
|
"\xd2i\xad\xfb\xa6\x7f\xfd\xe6/2Qt\\\xfd\x15B" +
|
|
"\xce\xdf\xb0\xf9\xfa\x9d\xed7\xbe\xfdv6\x8a\x8e\xa8\x81" +
|
|
"\xb5\x1fW\xc9\x98\xcf(\xf7\xa8'~\xf8\xd7\xef\xd0C" +
|
|
"r\xab5_U\xb7\xa0\xfa\x16=\xb4\xf2\x97j\xa0C" +
|
|
"\x12\xcds\xf9\xfa\xd4\xf9}\xa8\xbe{>\xc9u\xfa|" +
|
|
"\x92\xeb\xaa\xed\xfdb\xeb7\xae}\x0f\x94\x1e6#7" +
|
|
"/\xbe\xa0\x0f\xd5\xab.\xa0C+.\x90Q}\x8b>" +
|
|
"\xfd\xef\xd6\xb7\xbc\xf2\xc1\xe0\x0f\x7f\xd7zy\xa0\xd0+" +
|
|
"t\xe4Tp\xe4\xcd\x0b\x02\xf3\xaf\\\xf1\x17\xbf=\xfc" +
|
|
"\x97\x83\x1f\xcc\xba\xfd+\xdd\x03\xa8\xae\xe8&9\x96w" +
|
|
"\x7fK\xdd\xd6\x1d\\\xfe\x9d\xd5\x1b\xaf^\xf6\x93\x0f\xb3" +
|
|
"\x96\x18\xea\xfe\x90,q]7Yb\xfc\x1b\xbf\xf9\xd6" +
|
|
"\xc5\xdf\xfd\xa7\x0f[\xdc\x130Nu_\x8a\xea\xed\xc1" +
|
|
"\x8d\xb7\x10\xf3\xfbk~\xf0FO\xa1\xe7\xa3\xb9\x04}" +
|
|
"\xa4\x9b\xe2\xa4;\x88\x93\xee@\xd0k\x7fu\xf4\x86\xd2" +
|
|
"\xf7?\xfa\x98\xf4b-\xc8\xf3n\xcf\x16T?\xeb\xa1" +
|
|
"\x9b?\xe9\xa1\xf0_\xf7\xd8\xa9oN\x1c~\xf9\x93V" +
|
|
"#\x04\x0e9~\xe1\x01T\x9f\xbb\x90\xb8\x9f\xbd\x90\xf0" +
|
|
"c\xdf\xfbG\x86\xef\xda\xfa\xd8\xe7Y\xad\x1eX\xf2|" +
|
|
"\xe0\xdf%\xa4\xd5\xce\xc3\xfb\xdc\xe1\xfb\xee\xf4\xe7J\x96" +
|
|
"W\x97\x0c\xa0\xfa\xcb%t\xdb\xa9%O\xc0r\xdf\xf5" +
|
|
"LS\x18v3W\xfd\xc3\xf8\xb3zyUk\x9a\xcd" +
|
|
"\xbe\xa1I\xddqu\xb3>\x16\xd0Ke\xcb\xd0\xabS" +
|
|
"eD\xde\x81\x12\x80\xb2\xb4\x0f\x00Q\xf9\xd2\x16\x00\x94" +
|
|
"\x14e\x00\xa0\xa4\xd7M\xcb\x16~Mw\xaa\x96i\x0a" +
|
|
"`Uw\xff\x0e\xcd\xd0\xcc\xaaH\x1ej\x9b\xfd\xd0\xb0" +
|
|
"0\x0c\xeb\x1a\xcb6j\x1bm\xbd\xae\x9b\x83\x969\xae" +
|
|
"\xd7\x01\xca\x88\xc91y\xf6\xb1AC\x17\xa6[\x11\xf6" +
|
|
"\x1e\xbd*.\xf7\x1c\x11\x9e\xf3l\xcd\xd5-\xf3\xa2Q" +
|
|
"\xe1x\x86\xeb\x00\xf0\x1c\xcb\x01\xe4\x10@\xe9\xec\x03\xe0" +
|
|
"\x0b\x18\xf2.\x09Kv\xc0\x80\xc54\xf3\x00\xb1\x08\xe9" +
|
|
"\x9b\xf9\xd9o\x86\xb6\xa07\x85}\xb9g\xda\xa2\xae;" +
|
|
"\xae\xb0C\xf2E\xa5\xb2fk\x0d'\xfb\xe0Q\x00^" +
|
|
"d\xc8\x97H\xe8\xd7m\xad*\xca\xc2F\xdd\xaam\xd0" +
|
|
"L\xab\xc2D\x15\xdb@\xc2\xb6\xcc\xa3s8b\x8d\xa6" +
|
|
"\x1b\xa2\x16jwy\xb57\xf8?/\xb2\\\x87\xef\x07" +
|
|
"\x8fh[\x00\xf8v\x86\xdc\x90\xb0\x13?\xf7\xbb\xa8H" +
|
|
")\xfa^\x00>\xc1\x90\xbb\x12vJ\x9f\xf9]\x81\xd7" +
|
|
"v/\x03\xe0\x06C>)a'\xfb\xd4\xef\xa2R\xa0" +
|
|
"x;\x01\xb8\xcb\x90\xdf$\xa1\xefxM\xb2\xa9\x03\xcc" +
|
|
"\xb2\xb1\x98\x86rd\x1dQ\xab\x93\xa5M(\x89*\x19" +
|
|
"\x1a\x8b1\xe2\x86\x0cr\xcd\x9a\xc0bZ\"\xa2c\xb6" +
|
|
"\xd8#lG\x94\xa1`[\x93SXL\x91\xb7\xc5\xea" +
|
|
"\x9d\xe7j\xf5\xd8\xd1\xc9\xa9\xf9\xcf\x07\xa1Yu/*" +
|
|
"\xf7\xcer\x16\xd9\xb1\x83!\xff\xb2\x84~\x93~\x15\xae" +
|
|
"\x00f;XLKo\x8b\xb4s\x84\xf3 \xfdw0" +
|
|
"|\xa5\x1c\xddb;A8\xf3%\xc9c\xcf\xd2c\xcf" +
|
|
"0\xe4/H\xa8 \x86>;i\x03\xf0\x13\x0c\xf9\xcb" +
|
|
"\x12\xa2\x14z\xec\xc5c\x00\xfce\x86\xfc\x0d\x09\x15&" +
|
|
"\x85\x0e{\xfdR\x00\xfe/\x0c\xf9\xaf%Tr\xac\x8b" +
|
|
"\xda\x0c\xe54\x05\xdb\xaf\x19\xf2\x8f$T\xdar]\xd8" +
|
|
"\x06\xa0|@\x9c\xbfa\xc8\xff[B%\xdf\xd6\x85y" +
|
|
"\x00\xe5\xbf\xae\x04\xe0\xbfc\xc8?\x95\xd0\xb7\xc2\xa4#" +
|
|
"M]\xec\x04\x09;\x01\xfd\xaaay\xb5qC\x83^" +
|
|
"[\xd4FV't\xd3k\x94m\xb1GG\xcbs\xfa" +
|
|
"]W4\xe4\xa6\xeb`\x1e$\xcc\x03\x16\\\xad\xee\xe0" +
|
|
"b\xc02C,\xa6\xd5\x0f\x90\x88\xc9\x9dh\x8b\xdaf" +
|
|
"a;:\xb3L\xec\x00\x09;\x00\x0b\xa6\xd6\x10\xf1?" +
|
|
"z\xeb\xb6\xe55\xe3\x7f\xcdg\xeb\xd1(\xaa(\xa6\xa2" +
|
|
"\x04\xb1l]\xae\xeb&\xef`\xb9%\xbe\x1f\x19v\x88" +
|
|
"\xac\xb0\x8a!_'\xe1R\xfc\x9c\xc8d\xdb\x91Q\x00" +
|
|
">\xcc\x90\x8fI\xb8T\xfa\x8c\xc8d]N\xbe)3" +
|
|
"\xe4[%,L\xb8n\x13\x8bi\xd5\x8c\x02\xe0\x06\xb1" +
|
|
"\xc3\xb1\xaa\xbb\x04 AH\x02\xe1\xd1\xaf\x13\x11\xa4\x01" +
|
|
"3jXL\xfb\xd0\x96\xe8asDO\x108%w" +
|
|
"\xc8\xb6-;@\xdb$d\x86\xaeL\x95\x88#fd" +
|
|
"K\xaa\x81\"\xad\x0a\xd5\xe2;R\xf9{\xab\x9a\xe7$" +
|
|
"\x96\xf5m\xe1\xdaS\xfd\xe3.0a'\xd8\xe3LX" +
|
|
"\x9eQ\x1b\x15 \xbb\xf6\x14\"H\x88\xf3#\xd2jk" +
|
|
"8c\xf20\xb43r\x92L\xab\x19\xf2r*\xe7z" +
|
|
"\xa2\xadc\xc8\xaf%9#\xf3o\"\xf3\x8f1\xe4M" +
|
|
"\x09}\x83r\xda\x1c\xb6\x809n\"nH,[A" +
|
|
"l\xca \xa1\x0c\xe8{M\xc7\xb5\x85\xd6\x00L\x82\x8d" +
|
|
"\xf8\x17\x9f\x03t\xb7@HY+\x04X0\xb7\x0eI" +
|
|
"z\xae_\x9bU\"\xca\xcfM\x03\xa9\xb1\xe7\xce\xa5\x09" +
|
|
"\xcbq)\xbc\x01 Vl\xbf\xd5$\xec$dIZ" +
|
|
"\xca\x96\xd88\xf7\x8a\x17V\x9f\x19\xf5\xeeX\xa6\xfcT" +
|
|
"\xa3\xd3\x18\x1c\x1f\xb4Ly\\\xafc1\xed\xc1Z\x04" +
|
|
"\x98\xc3\xef\xfd\x9e;!LW\xaf\x06\x0f\xce\xf2\xfb\xb2" +
|
|
"4>\x13\x9b\x8d\\\x991dl\xb3\xf5;RC\xca" +
|
|
"\xbb\xc4T\x92\xf8\xa2\xa1\xe9F\xe2\xfd\xc8\x9a\xfd \x7f" +
|
|
";\xe5\x99\xb7e\x89jSX\x99J\xa1yH\xc8\xae" +
|
|
"D\xc8\x1b\xa7\x01\xf8M\x0c\xf9\x1d\x19!o\xbf\x07\x80" +
|
|
"\xdf\xc1\x90\xdf\x97\x11\xf209\xf6\x10C~?\x01/" +
|
|
"\x0b\xa1\xe1\x08Y\xf4~\x86\xfca\x091\x17\xe2\xeeq" +
|
|
"\xc2\xdd\x87\x19\xf2g\xa4\x00 \x87\xfb\x07-\x13#!" +
|
|
"\x1c\x80\x18\x1e\xfd\x09\xa1\xd9\xee\x0e\xa1\xa1;b\xba\xc2" +
|
|
"\xde\xa3\xa1\x11\xe7\xe0~Wo\x08\xcbs\x93\x9clh" +
|
|
"\x93A\xdd\xc7\xdapxJ\xd6\\\x07\xdbA\xc2vJ" +
|
|
"\x01G\xd8\x83\xb6\xa8!yC3\xca\x1as'\xce\xc6" +
|
|
"@3\xf1\xb20\x87y\xa8k\xd8\xc7\x90\xdfF\xb9\x8b" +
|
|
"\x99!R\xb9\xa5\x0f\xa4 uI\xe7\xc6@\xda]\x04" +
|
|
"U\x89j\xcd\xee{\xd26\"\xa8JTkn<\x9a" +
|
|
"\x1a<\x12m\xd8\x82R\x98\x12\xb1\xcc\xa5\xd0\xd5\xfb\x09" +
|
|
"\x9et\x91\xea\x19\x15k\x1d-s,0\x10\xa6\x16\xaa" +
|
|
"Z\x8d\xa6-\x1c\x07u\xcb\xe4\x9ef\xe8\xcc\x9dJ\x0e" +
|
|
"\xcek\x03\xca\xfd0g66{\x03'\x91\x11\xae\x88" +
|
|
"\x8d\xa0\xf6\xe3Z\x80\xca*dXY\x87i\x98\xa8#" +
|
|
"8\x00PYM\xf42\xa6\x91\xa2\xae\xc7\x1e\x80\xca0" +
|
|
"\xd1\xc7PB\x0ccE\xe5\xf8(@e\x8c\xc8\xdb1" +
|
|
"\xad\xd3\xea\xb6\xe0\xfa\xadD\x9f\xc0\xb4T\xab\x02/\x05" +
|
|
"\xa8l'\xfa>\xa2\xe7\xa5\xc0\x82\xea\x14\xee\x04\xa8L" +
|
|
"\x12\xfd \xd1\xe5\xb6.\xea\xfa\xd5\x9b\xd1\x06\xa8\xdcD" +
|
|
"\xf4;\x88\xbe\xe0\xcb]\xb8\x00@\xbd=\xa0\xdfF\xf4" +
|
|
"{\x89\xde\xde\xdd\x85\xed\x00\xea\xddx\x00\xa0r\x88\xe8" +
|
|
"\xf7\x13}!v\xe1B\x00\xf5\x08\x1e\x05\xa8\xdcO\xf4" +
|
|
"\x87\x89\xbe(\xdf\x85\x8b\x00\xd4\xe3\x81<\x0f\x12\xfd1" +
|
|
"L\x00d\xa4\x96\xc51\x0a'=-\xe3\xccr\x920" +
|
|
"\x14\xd1\xfc\x80!\xc8\x96\xad\x02\x0d\x10XH\xf77\x80" +
|
|
"X\x00\xf4\x9b\x96el\x98\x89\x8fg\xea$\xa2\xb0\x80" +
|
|
"\x82e\x8e\xd4\x92\xfc\x0a\x83h\x9d\x05\xbdU\xcd\x18I" +
|
|
"\x1b\x08\xdd\xe9\xf7\\\xcbkBoMsE-\xa9p" +
|
|
"\xb6g\xae\xb1\xad\xc6\x18\x0a\xbb\xa1\x9b\x9a\x01\xc9/\xf3" +
|
|
"\xc5V\xc1\xf3\xf4\xda\xacd\x93Z\x03\xad\xb7\xd97\xa6" +
|
|
"\x05\xd9\xb5 \xc9\xaeK\xa8\x0d\xb9\x88!\xbf\"\x03>" +
|
|
"\xcb\x09!\xbf\xc6\x90\xff\x91\xd4\xd2\x06\xed\xd1\x0cO\x9c" +
|
|
"M\x1b\xb4\xa9\xa5\x14\x84-q\x88\xcf\x99\xd7\x07\xd2\xd7" +
|
|
"\x93\xc7\xa9\xe3\xbc\x8c!\x1f\x96p\xbf\xe3U\xab\xa4t" +
|
|
"l\x85\xf1h\xf0\x80^\xba;\xe3\x8fd'\x10\xf9\xe3" +
|
|
"l\xcbn]\xb8\xe1\xd7\x889nQ\xbd\x92\xb5\x86\xf3" +
|
|
"\x7f<=*\x9c\x02\xf5\xfdg\x1c\xef\x92)\xff\xcc\xf5" +
|
|
"mxl\xac\x9c\xce\xa0,\x04\xc7,.\x8cfq!" +
|
|
"\x85\x85\x9d\xd9\xf4\x8f\xdb0\x95\x07yX&\xfaVL" +
|
|
"\x9bw\xf5:<6#\xffs\xfd!.\x88\xe0\xfa\x1a" +
|
|
"\xd1\x9b\x01.`\x88\x0b\x8d\xe0~\x83\xe8\x93Y\\\xf0" +
|
|
"pz&.\xb0\x18\x17(\x9f\x0f\x12\xfdP\x80\x0b\xb9" +
|
|
"\x10\x17\xee\xc4\xa7g\xe4\x7f{[\x88\x0bG\xf0\xf9\x19" +
|
|
"\xf9\xbf0\x1f\xe2\xc2\xf1\x80\xffa\xa2?\x13\xe0\xc2@" +
|
|
"\x88\x0bO\x058\xf2$\xd1O\x10.x\xb6Qqm" +
|
|
"\xdd\x04\xac\xa7\xc1Zm~[\x88f?\x14\x0c}\x8f" +
|
|
"H0\xbb\xa6k\xc6jO3\xa0\xb7\xe2j\xd5]i" +
|
|
"\xafi8\xc3\x9aYspB\xdb%\x08\xe9\xe5l-" +
|
|
"t\x0dg\xb3\xb0\xf5q\xc0\xb4;Mz\x83B\xd9\xb2" +
|
|
"Z[\x86\xa0\xc9\x11v\x08*\xc9o\x0dmr\xa4f" +
|
|
"\x88A\x8c;\x04f\xa6\x95F\xa7_,\xd3\xc4\xb0l" +
|
|
"\x8f\xe9\xbd3\xebq3\xeaw\xe3\xba>Vj)\xd8" +
|
|
"b\xb2)\xaa\xee\xa0\x85\xa6\xab\x9b\x9e\x98uAu\xc2" +
|
|
"3w\x89\xda\x10\x9aU\xab\xa6\x9bu\x98\xd5h\xb3/" +
|
|
"\x1a\xfd3\x8dL\x90\xcd\x98\xd98+\x97PY\xc6\xa8" +
|
|
",+}\xe9\x08[\xaa\x06\xa7J\xb6\xd0\x9c\x14\xa1\xe7" +
|
|
"{-\xda\xf4\x84IF\xaf\x15Y\x1b@\xb2\xbf\xc5x" +
|
|
"\xa1\xa6\xec\xde\x0b\x92\xa2\xcb\x98\xee!1^;*\xdb" +
|
|
"l\x90\x94M2J\xc9\xda\x1c\xe3\x95\xb722\x0d\x92" +
|
|
"2$#Kv\xdd\x18\xaf\xb3\x94\xab\x07@R\x96\xcb" +
|
|
"~\xdc\x9aC)\x14g\x15\xfaq\xe2Co\x90\xfa\xab" +
|
|
"\xd0\x8f\x97\x00\x18\xb7\xf0\x00\xabp\x7fT\x16Vav" +
|
|
"s\xc4\xbe\xa8\x8f\x9e\xbb=$\x8c\x9cd\xc8\x0f\xa6\x18" +
|
|
"y3\xb5\x8c\x07\x19\xf2C\x99\xd9\xe5\xceG\xb3\xdda" +
|
|
"4\x96\x1f9\x00\xc0\xef\x0b;\xc1d,\x7f\xeaX4" +
|
|
"\xe9\xffLJ\xebe\x1cv\xf1\xb2\x05-;\x1e\xa6\xe6" +
|
|
"\xd9\xb9D\xc1\x19un\xad\x9b\x17\xbffM\x04\x9d\x1d" +
|
|
"\x86W9\x90\"vv\x1d\xb38\xb3\x8e\xc1x\x8c\x93" +
|
|
"g\x00|v9\xb3x~\xcc\x9c1\x94\x04\x15'\x17" +
|
|
"DM\xbc\xd4\xc7\xf8\xcf+\x8aB\xde\xef\x94\xfdxp" +
|
|
"\xc1\xb8\\\x91\xf3\xb2.;\xc7\xe9mT\xf4:gS" +
|
|
"\x09\xe2\x15\xee\x99\x87\xf0\xf0\x9d\x02\x05[\xa8Pr\xef" +
|
|
"\xce\xcc\x8a\xc8\xb0\xa29\xa8\xb0!S\xb5\xe7\xb3U(" +
|
|
"p\xdc\x80\x16\xe8pK\xf8-K\xc3/i\x10n^" +
|
|
"\x96\xf6\xe4\xc9tr\xcb\xda((\x1fL\x1aN\xe5\x01" +
|
|
"\x0a\xd4\x07\x19\xf2\xc72\xe1\xf7\xc8\xdat:\x91\x85m" +
|
|
"\xc7r\xca\x9e\x9d\xc2\xa6a\xd5\xd7\xe9\xa6p\xa8\x05k" +
|
|
"\x19\xa9\x9b\xc2nh\xa60\xd1%0\xf2lB\xd4\x99" +
|
|
"\xc85\xb2:\xd3\xb9\xcd\xa7~%\x0a\xf60\xd6\xa3\xf2" +
|
|
"\x9a\x99\x1f\x8fev\x19\xb1\xf2\xfc\xf9hG\xb0=\xa3" +
|
|
"\xfc6\x9a\x1f\xb72\xe4\x13\x12\xfa\x9a\xe7Z\x9b\x9a5" +
|
|
"\x0d]\xb1\xc6\x16\xbb=!\x9b\xd5\xa9t\x8e\xa2\x89\xa2" +
|
|
"\xeal\xc2&\xf5~klQ\xda\xed\x89,C\xbc\x95" +
|
|
"\x05Y\xb7j\xb3\xd6\xb1s4[\xd7\x88\x1d\x15\xab\xba" +
|
|
"K\xb83\xb6\xd5!\\\xc6\xaah\xa3\xe9J6\xd6D" +
|
|
"\x1f\xcd\x8cL1\x8c\xec\xa6\x80j2\xe4\xfb202" +
|
|
"5\x9d:|\xee\xea\xfa\xffS\x10\xe7Qr\xce\x95\xe9" +
|
|
"hI\x9cU\xa2\xa5\x7f\x828s\xcb\x15\x8d\xebQ\xc7" +
|
|
"z6\x0b\x85\x19\x1b\xaf( \xf8\xcet\x09\x13\x04y" +
|
|
"1\xfd\x8bf$\x83\x13\xb5\x8e\xc0\xc6\xad9\xba\xc2p" +
|
|
"\xb8\x19\xb4 \x82\xd6\xd6\xb5\xc8\xff\x06\x00\x00\xff\xffX" +
|
|
"t1W"
|
|
|
|
func init() {
|
|
schemas.Register(schema_db8274f9144abc7e,
|
|
0x84cb9536a2cf6d3c,
|
|
0x8891f360e47c30d3,
|
|
0x91f7a001ca145b9d,
|
|
0x9b87b390babc2ccf,
|
|
0x9e12cfad042ba4f1,
|
|
0xa29a916d4ebdd894,
|
|
0xa766b24d4fe5da35,
|
|
0xa78f37418c1077c8,
|
|
0xaa7386f356bd398a,
|
|
0xb14ce48f4e2abb0d,
|
|
0xb167b0bebe562cd0,
|
|
0xb70431c0dc014915,
|
|
0xb9d4ef45c2b5fc5b,
|
|
0xc082ef6e0d42ed1d,
|
|
0xc744e349009087aa,
|
|
0xc766a92976e389c4,
|
|
0xc793e50592935b4a,
|
|
0xcbd96442ae3bb01a,
|
|
0xd58a254e7a792b87,
|
|
0xdc3ed6801961e502,
|
|
0xe3e37d096a5b564e,
|
|
0xe4a6a1bc139211b4,
|
|
0xea20b390b257d1a5,
|
|
0xea58385c65416035,
|
|
0xf0a143f1c95a678e,
|
|
0xf143a395ed8b3133,
|
|
0xf2c122394f447e8e,
|
|
0xf2c68e2547ec3866,
|
|
0xf41a0f001ad49e46,
|
|
0xf7f49b3f779ae258,
|
|
0xf9c895683ed9ac4c,
|
|
0xfeac5c8f4899ef7c,
|
|
0xff8d9848747c956a)
|
|
}
|