1907 lines
64 KiB
Go
1907 lines
64 KiB
Go
// Code generated by capnpc-go. DO NOT EDIT.
|
|
|
|
package tunnelrpc
|
|
|
|
import (
|
|
context "golang.org/x/net/context"
|
|
capnp "zombiezen.com/go/capnproto2"
|
|
text "zombiezen.com/go/capnproto2/encoding/text"
|
|
schemas "zombiezen.com/go/capnproto2/schemas"
|
|
server "zombiezen.com/go/capnproto2/server"
|
|
)
|
|
|
|
type Authentication struct{ capnp.Struct }
|
|
|
|
// Authentication_TypeID is the unique identifier for the type Authentication.
|
|
const Authentication_TypeID = 0xc082ef6e0d42ed1d
|
|
|
|
func NewAuthentication(s *capnp.Segment) (Authentication, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return Authentication{st}, err
|
|
}
|
|
|
|
func NewRootAuthentication(s *capnp.Segment) (Authentication, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return Authentication{st}, err
|
|
}
|
|
|
|
func ReadRootAuthentication(msg *capnp.Message) (Authentication, error) {
|
|
root, err := msg.RootPtr()
|
|
return Authentication{root.Struct()}, err
|
|
}
|
|
|
|
func (s Authentication) String() string {
|
|
str, _ := text.Marshal(0xc082ef6e0d42ed1d, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s Authentication) Key() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s Authentication) HasKey() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s Authentication) KeyBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s Authentication) SetKey(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s Authentication) Email() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s Authentication) HasEmail() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s Authentication) EmailBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s Authentication) SetEmail(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s Authentication) OriginCAKey() (string, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s Authentication) HasOriginCAKey() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s Authentication) OriginCAKeyBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s Authentication) SetOriginCAKey(v string) error {
|
|
return s.Struct.SetText(2, v)
|
|
}
|
|
|
|
// Authentication_List is a list of Authentication.
|
|
type Authentication_List struct{ capnp.List }
|
|
|
|
// NewAuthentication creates a new list of Authentication.
|
|
func NewAuthentication_List(s *capnp.Segment, sz int32) (Authentication_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
|
|
return Authentication_List{l}, err
|
|
}
|
|
|
|
func (s Authentication_List) At(i int) Authentication { return Authentication{s.List.Struct(i)} }
|
|
|
|
func (s Authentication_List) Set(i int, v Authentication) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
// Authentication_Promise is a wrapper for a Authentication promised by a client call.
|
|
type Authentication_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p Authentication_Promise) Struct() (Authentication, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return Authentication{s}, err
|
|
}
|
|
|
|
type TunnelRegistration struct{ capnp.Struct }
|
|
|
|
// TunnelRegistration_TypeID is the unique identifier for the type TunnelRegistration.
|
|
const TunnelRegistration_TypeID = 0xf41a0f001ad49e46
|
|
|
|
func NewTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// 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: 3})
|
|
return CapnpConnectParameters{st}, err
|
|
}
|
|
|
|
func NewRootCapnpConnectParameters(s *capnp.Segment) (CapnpConnectParameters, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
|
|
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
|
|
}
|
|
|
|
// 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: 3}, 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)
|
|
}
|
|
|
|
// 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: 2})
|
|
return ConnectResult{st}, err
|
|
}
|
|
|
|
func NewRootConnectResult(s *capnp.Segment) (ConnectResult, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
|
|
return ConnectResult{st}, err
|
|
}
|
|
|
|
func ReadRootConnectResult(msg *capnp.Message) (ConnectResult, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConnectResult{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectResult) String() string {
|
|
str, _ := text.Marshal(0xff8d9848747c956a, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConnectResult) Err() (ConnectError, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return ConnectError{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectResult) HasErr() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectResult) SetErr(v ConnectError) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewErr sets the err field to a newly
|
|
// allocated ConnectError struct, preferring placement in s's segment.
|
|
func (s ConnectResult) NewErr() (ConnectError, error) {
|
|
ss, err := NewConnectError(s.Struct.Segment())
|
|
if err != nil {
|
|
return ConnectError{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ConnectResult) ServerInfo() (ServerInfo, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return ServerInfo{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectResult) HasServerInfo() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectResult) SetServerInfo(v ServerInfo) error {
|
|
return s.Struct.SetPtr(1, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewServerInfo sets the serverInfo field to a newly
|
|
// allocated ServerInfo struct, preferring placement in s's segment.
|
|
func (s ConnectResult) NewServerInfo() (ServerInfo, error) {
|
|
ss, err := NewServerInfo(s.Struct.Segment())
|
|
if err != nil {
|
|
return ServerInfo{}, err
|
|
}
|
|
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// ConnectResult_List is a list of ConnectResult.
|
|
type ConnectResult_List struct{ capnp.List }
|
|
|
|
// NewConnectResult creates a new list of ConnectResult.
|
|
func NewConnectResult_List(s *capnp.Segment, sz int32) (ConnectResult_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
|
|
return ConnectResult_List{l}, err
|
|
}
|
|
|
|
func (s ConnectResult_List) At(i int) ConnectResult { return ConnectResult{s.List.Struct(i)} }
|
|
|
|
func (s ConnectResult_List) Set(i int, v ConnectResult) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
// ConnectResult_Promise is a wrapper for a ConnectResult promised by a client call.
|
|
type ConnectResult_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConnectResult_Promise) Struct() (ConnectResult, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConnectResult{s}, err
|
|
}
|
|
|
|
func (p ConnectResult_Promise) Err() ConnectError_Promise {
|
|
return ConnectError_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
func (p ConnectResult_Promise) ServerInfo() ServerInfo_Promise {
|
|
return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
|
|
}
|
|
|
|
type ConnectError struct{ capnp.Struct }
|
|
|
|
// ConnectError_TypeID is the unique identifier for the type ConnectError.
|
|
const ConnectError_TypeID = 0xb14ce48f4e2abb0d
|
|
|
|
func NewConnectError(s *capnp.Segment) (ConnectError, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
|
|
return ConnectError{st}, err
|
|
}
|
|
|
|
func NewRootConnectError(s *capnp.Segment) (ConnectError, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
|
|
return ConnectError{st}, err
|
|
}
|
|
|
|
func ReadRootConnectError(msg *capnp.Message) (ConnectError, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConnectError{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectError) String() string {
|
|
str, _ := text.Marshal(0xb14ce48f4e2abb0d, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConnectError) Cause() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s ConnectError) HasCause() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectError) CauseBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s ConnectError) SetCause(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s ConnectError) RetryAfter() int64 {
|
|
return int64(s.Struct.Uint64(0))
|
|
}
|
|
|
|
func (s ConnectError) SetRetryAfter(v int64) {
|
|
s.Struct.SetUint64(0, uint64(v))
|
|
}
|
|
|
|
func (s ConnectError) ShouldRetry() bool {
|
|
return s.Struct.Bit(64)
|
|
}
|
|
|
|
func (s ConnectError) SetShouldRetry(v bool) {
|
|
s.Struct.SetBit(64, v)
|
|
}
|
|
|
|
// ConnectError_List is a list of ConnectError.
|
|
type ConnectError_List struct{ capnp.List }
|
|
|
|
// NewConnectError creates a new list of ConnectError.
|
|
func NewConnectError_List(s *capnp.Segment, sz int32) (ConnectError_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}, sz)
|
|
return ConnectError_List{l}, err
|
|
}
|
|
|
|
func (s ConnectError_List) At(i int) ConnectError { return ConnectError{s.List.Struct(i)} }
|
|
|
|
func (s ConnectError_List) Set(i int, v ConnectError) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
// 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 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) }
|
|
|
|
// Tag_Promise is a wrapper for a Tag promised by a client call.
|
|
type Tag_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p Tag_Promise) Struct() (Tag, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return Tag{s}, err
|
|
}
|
|
|
|
type ExistingTunnelPolicy uint16
|
|
|
|
// ExistingTunnelPolicy_TypeID is the unique identifier for the type ExistingTunnelPolicy.
|
|
const ExistingTunnelPolicy_TypeID = 0x84cb9536a2cf6d3c
|
|
|
|
// Values of ExistingTunnelPolicy.
|
|
const (
|
|
ExistingTunnelPolicy_ignore ExistingTunnelPolicy = 0
|
|
ExistingTunnelPolicy_disconnect ExistingTunnelPolicy = 1
|
|
ExistingTunnelPolicy_balance ExistingTunnelPolicy = 2
|
|
)
|
|
|
|
// String returns the enum's constant name.
|
|
func (c ExistingTunnelPolicy) String() string {
|
|
switch c {
|
|
case ExistingTunnelPolicy_ignore:
|
|
return "ignore"
|
|
case ExistingTunnelPolicy_disconnect:
|
|
return "disconnect"
|
|
case ExistingTunnelPolicy_balance:
|
|
return "balance"
|
|
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
// ExistingTunnelPolicyFromString returns the enum value with a name,
|
|
// or the zero value if there's no such value.
|
|
func ExistingTunnelPolicyFromString(c string) ExistingTunnelPolicy {
|
|
switch c {
|
|
case "ignore":
|
|
return ExistingTunnelPolicy_ignore
|
|
case "disconnect":
|
|
return ExistingTunnelPolicy_disconnect
|
|
case "balance":
|
|
return ExistingTunnelPolicy_balance
|
|
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
type ExistingTunnelPolicy_List struct{ capnp.List }
|
|
|
|
func NewExistingTunnelPolicy_List(s *capnp.Segment, sz int32) (ExistingTunnelPolicy_List, error) {
|
|
l, err := capnp.NewUInt16List(s, sz)
|
|
return ExistingTunnelPolicy_List{l.List}, err
|
|
}
|
|
|
|
func (l ExistingTunnelPolicy_List) At(i int) ExistingTunnelPolicy {
|
|
ul := capnp.UInt16List{List: l.List}
|
|
return ExistingTunnelPolicy(ul.At(i))
|
|
}
|
|
|
|
func (l ExistingTunnelPolicy_List) Set(i int, v ExistingTunnelPolicy) {
|
|
ul := capnp.UInt16List{List: l.List}
|
|
ul.Set(i, uint16(v))
|
|
}
|
|
|
|
type ServerInfo struct{ capnp.Struct }
|
|
|
|
// ServerInfo_TypeID is the unique identifier for the type ServerInfo.
|
|
const ServerInfo_TypeID = 0xf2c68e2547ec3866
|
|
|
|
func NewServerInfo(s *capnp.Segment) (ServerInfo, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return ServerInfo{st}, err
|
|
}
|
|
|
|
func NewRootServerInfo(s *capnp.Segment) (ServerInfo, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return ServerInfo{st}, err
|
|
}
|
|
|
|
func ReadRootServerInfo(msg *capnp.Message) (ServerInfo, error) {
|
|
root, err := msg.RootPtr()
|
|
return ServerInfo{root.Struct()}, err
|
|
}
|
|
|
|
func (s ServerInfo) String() string {
|
|
str, _ := text.Marshal(0xf2c68e2547ec3866, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ServerInfo) LocationName() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s ServerInfo) HasLocationName() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ServerInfo) LocationNameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s ServerInfo) SetLocationName(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
// ServerInfo_List is a list of ServerInfo.
|
|
type ServerInfo_List struct{ capnp.List }
|
|
|
|
// NewServerInfo creates a new list of ServerInfo.
|
|
func NewServerInfo_List(s *capnp.Segment, sz int32) (ServerInfo_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return ServerInfo_List{l}, err
|
|
}
|
|
|
|
func (s ServerInfo_List) At(i int) ServerInfo { return ServerInfo{s.List.Struct(i)} }
|
|
|
|
func (s ServerInfo_List) Set(i int, v ServerInfo) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
// ServerInfo_Promise is a wrapper for a ServerInfo promised by a client call.
|
|
type ServerInfo_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ServerInfo_Promise) Struct() (ServerInfo, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ServerInfo{s}, err
|
|
}
|
|
|
|
type 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)
|
|
}
|
|
|
|
// TunnelServer_registerTunnel_Params_Promise is a wrapper for a TunnelServer_registerTunnel_Params promised by a client call.
|
|
type TunnelServer_registerTunnel_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_registerTunnel_Params_Promise) Struct() (TunnelServer_registerTunnel_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_registerTunnel_Params{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_registerTunnel_Params_Promise) Options() RegistrationOptions_Promise {
|
|
return RegistrationOptions_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
|
|
}
|
|
|
|
type TunnelServer_registerTunnel_Results struct{ capnp.Struct }
|
|
|
|
// TunnelServer_registerTunnel_Results_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Results.
|
|
const TunnelServer_registerTunnel_Results_TypeID = 0xf2c122394f447e8e
|
|
|
|
func NewTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_registerTunnel_Results{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_registerTunnel_Results{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_registerTunnel_Results(msg *capnp.Message) (TunnelServer_registerTunnel_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_registerTunnel_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results) String() string {
|
|
str, _ := text.Marshal(0xf2c122394f447e8e, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results) Result() (TunnelRegistration, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return TunnelRegistration{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results) HasResult() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results) SetResult(v TunnelRegistration) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewResult sets the result field to a newly
|
|
// allocated TunnelRegistration struct, preferring placement in s's segment.
|
|
func (s TunnelServer_registerTunnel_Results) NewResult() (TunnelRegistration, error) {
|
|
ss, err := NewTunnelRegistration(s.Struct.Segment())
|
|
if err != nil {
|
|
return TunnelRegistration{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_registerTunnel_Results_List is a list of TunnelServer_registerTunnel_Results.
|
|
type TunnelServer_registerTunnel_Results_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_registerTunnel_Results creates a new list of TunnelServer_registerTunnel_Results.
|
|
func NewTunnelServer_registerTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return TunnelServer_registerTunnel_Results_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results_List) At(i int) TunnelServer_registerTunnel_Results {
|
|
return TunnelServer_registerTunnel_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results_List) Set(i int, v TunnelServer_registerTunnel_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_registerTunnel_Results_Promise is a wrapper for a TunnelServer_registerTunnel_Results promised by a client call.
|
|
type TunnelServer_registerTunnel_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_registerTunnel_Results_Promise) Struct() (TunnelServer_registerTunnel_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_registerTunnel_Results{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_registerTunnel_Results_Promise) Result() TunnelRegistration_Promise {
|
|
return TunnelRegistration_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type TunnelServer_getServerInfo_Params struct{ capnp.Struct }
|
|
|
|
// TunnelServer_getServerInfo_Params_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Params.
|
|
const TunnelServer_getServerInfo_Params_TypeID = 0xdc3ed6801961e502
|
|
|
|
func NewTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_getServerInfo_Params{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_getServerInfo_Params{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_getServerInfo_Params(msg *capnp.Message) (TunnelServer_getServerInfo_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_getServerInfo_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Params) String() string {
|
|
str, _ := text.Marshal(0xdc3ed6801961e502, s.Struct)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_getServerInfo_Params_List is a list of TunnelServer_getServerInfo_Params.
|
|
type TunnelServer_getServerInfo_Params_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_getServerInfo_Params creates a new list of TunnelServer_getServerInfo_Params.
|
|
func NewTunnelServer_getServerInfo_Params_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
|
|
return TunnelServer_getServerInfo_Params_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Params_List) At(i int) TunnelServer_getServerInfo_Params {
|
|
return TunnelServer_getServerInfo_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Params_List) Set(i int, v TunnelServer_getServerInfo_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_getServerInfo_Params_Promise is a wrapper for a TunnelServer_getServerInfo_Params promised by a client call.
|
|
type TunnelServer_getServerInfo_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_getServerInfo_Params_Promise) Struct() (TunnelServer_getServerInfo_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_getServerInfo_Params{s}, err
|
|
}
|
|
|
|
type TunnelServer_getServerInfo_Results struct{ capnp.Struct }
|
|
|
|
// TunnelServer_getServerInfo_Results_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Results.
|
|
const TunnelServer_getServerInfo_Results_TypeID = 0xe3e37d096a5b564e
|
|
|
|
func NewTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_getServerInfo_Results{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_getServerInfo_Results{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_getServerInfo_Results(msg *capnp.Message) (TunnelServer_getServerInfo_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_getServerInfo_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results) String() string {
|
|
str, _ := text.Marshal(0xe3e37d096a5b564e, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results) Result() (ServerInfo, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return ServerInfo{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results) HasResult() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results) SetResult(v ServerInfo) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewResult sets the result field to a newly
|
|
// allocated ServerInfo struct, preferring placement in s's segment.
|
|
func (s TunnelServer_getServerInfo_Results) NewResult() (ServerInfo, error) {
|
|
ss, err := NewServerInfo(s.Struct.Segment())
|
|
if err != nil {
|
|
return ServerInfo{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_getServerInfo_Results_List is a list of TunnelServer_getServerInfo_Results.
|
|
type TunnelServer_getServerInfo_Results_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_getServerInfo_Results creates a new list of TunnelServer_getServerInfo_Results.
|
|
func NewTunnelServer_getServerInfo_Results_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return TunnelServer_getServerInfo_Results_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results_List) At(i int) TunnelServer_getServerInfo_Results {
|
|
return TunnelServer_getServerInfo_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results_List) Set(i int, v TunnelServer_getServerInfo_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_getServerInfo_Results_Promise is a wrapper for a TunnelServer_getServerInfo_Results promised by a client call.
|
|
type TunnelServer_getServerInfo_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_getServerInfo_Results_Promise) Struct() (TunnelServer_getServerInfo_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_getServerInfo_Results{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_getServerInfo_Results_Promise) Result() ServerInfo_Promise {
|
|
return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type TunnelServer_unregisterTunnel_Params struct{ capnp.Struct }
|
|
|
|
// TunnelServer_unregisterTunnel_Params_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Params.
|
|
const TunnelServer_unregisterTunnel_Params_TypeID = 0x9b87b390babc2ccf
|
|
|
|
func NewTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
|
|
return TunnelServer_unregisterTunnel_Params{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
|
|
return TunnelServer_unregisterTunnel_Params{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_unregisterTunnel_Params(msg *capnp.Message) (TunnelServer_unregisterTunnel_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_unregisterTunnel_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Params) String() string {
|
|
str, _ := text.Marshal(0x9b87b390babc2ccf, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Params) GracePeriodNanoSec() int64 {
|
|
return int64(s.Struct.Uint64(0))
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Params) SetGracePeriodNanoSec(v int64) {
|
|
s.Struct.SetUint64(0, uint64(v))
|
|
}
|
|
|
|
// TunnelServer_unregisterTunnel_Params_List is a list of TunnelServer_unregisterTunnel_Params.
|
|
type TunnelServer_unregisterTunnel_Params_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_unregisterTunnel_Params creates a new list of TunnelServer_unregisterTunnel_Params.
|
|
func NewTunnelServer_unregisterTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz)
|
|
return TunnelServer_unregisterTunnel_Params_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Params_List) At(i int) TunnelServer_unregisterTunnel_Params {
|
|
return TunnelServer_unregisterTunnel_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Params_List) Set(i int, v TunnelServer_unregisterTunnel_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_unregisterTunnel_Params_Promise is a wrapper for a TunnelServer_unregisterTunnel_Params promised by a client call.
|
|
type TunnelServer_unregisterTunnel_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_unregisterTunnel_Params_Promise) Struct() (TunnelServer_unregisterTunnel_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_unregisterTunnel_Params{s}, err
|
|
}
|
|
|
|
type TunnelServer_unregisterTunnel_Results struct{ capnp.Struct }
|
|
|
|
// TunnelServer_unregisterTunnel_Results_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Results.
|
|
const TunnelServer_unregisterTunnel_Results_TypeID = 0xa29a916d4ebdd894
|
|
|
|
func NewTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_unregisterTunnel_Results{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_unregisterTunnel_Results{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_unregisterTunnel_Results(msg *capnp.Message) (TunnelServer_unregisterTunnel_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_unregisterTunnel_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Results) String() string {
|
|
str, _ := text.Marshal(0xa29a916d4ebdd894, s.Struct)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_unregisterTunnel_Results_List is a list of TunnelServer_unregisterTunnel_Results.
|
|
type TunnelServer_unregisterTunnel_Results_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_unregisterTunnel_Results creates a new list of TunnelServer_unregisterTunnel_Results.
|
|
func NewTunnelServer_unregisterTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
|
|
return TunnelServer_unregisterTunnel_Results_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Results_List) At(i int) TunnelServer_unregisterTunnel_Results {
|
|
return TunnelServer_unregisterTunnel_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Results_List) Set(i int, v TunnelServer_unregisterTunnel_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_unregisterTunnel_Results_Promise is a wrapper for a TunnelServer_unregisterTunnel_Results promised by a client call.
|
|
type TunnelServer_unregisterTunnel_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_unregisterTunnel_Results_Promise) Struct() (TunnelServer_unregisterTunnel_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_unregisterTunnel_Results{s}, err
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// 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)}
|
|
}
|
|
|
|
const schema_db8274f9144abc7e = "x\xda\x9cW]l\x1cW\x15>\xe7\xde\xdd\x9dx\x9d" +
|
|
"e=\x9a\x8d\xd4XT+\xa2\xa0B\xd4\x94\xa4\xa1\x90" +
|
|
"\x9a\x9f\xb5\x1d;d\x8d\xed\xec\xf5\xda(\xb4\xa9\x94\xc9" +
|
|
"\xee\xb5=fwf{g&\x89\xab\xa4I\xa3 J" +
|
|
"T\x9a\x86&\x82\x86\x82\xa2HQ\x0a\x8a\x80\x14\x10j" +
|
|
"i\xa5\xe6\x81\x1f\xa9\x0f}A\x88@_\xa0D\x88\x8a" +
|
|
"*\"\x82\x07x`\xd0\x99\xdd\x99\x9d\xaeM\xdc\xf6\xc5" +
|
|
"\x1a\x7f\xf7\xde\xf3}\xe7\xdes\xbf{v[)5\xcc" +
|
|
"\xb6\xa7\xbf\xa5\x01\x88}\xe9L\xf0\xd9\xe6\x1b\x97>u" +
|
|
"\xfe\xf5S\xa0\x0f\xb2\xe0\xf1W&\x0a\xff\xf6N\xfe\x11" +
|
|
"\x00w\\\xe3\x8f\xa1\xf1K\xae\x01\x18\xd7\xf9^\xc0\xe0" +
|
|
"\x8d{_y\xf9\x99\x9f|\xed; \xeeA\x04Hi" +
|
|
"\x00;n\xf0\xff \xa0\xf1\x0e/\x01\x06\xe7~\xff\xea" +
|
|
"t\xf3\xec\x85K\xa0\xdf\x13\x8doH1\x06\xa9\xe0\x81" +
|
|
"?\xdc\xdc;\xf5\xe2\xfc\x95\xf6H\x1ai\xa8/\xf5\"" +
|
|
"-\xdd\x98\xa2\xa5\xbf9<\xf0\xd4\xc8\xa7\xcf\\\x011" +
|
|
"\x88\xd8\x95\x91&\xfa\x1d\x9fK\x9dFc\x8e\xe2\x19\"" +
|
|
"\xf5W\xc0 \xf7\x8b-\xd3g\xfe2y\x8df'D" +
|
|
"\xb7\xe3\x8e\xa7\x87\xd0\x98K\x87\xb3\xd3?\x02\x0c6\x94" +
|
|
"\xf1\xcd\xd7\xb6\xa7~\xde!\x0fC\xfe#\xfd6\x91\xa7" +
|
|
"34\xe1\xeewFs\xf6\xad\x93\xaf\x81>\xb8\x82\xfb" +
|
|
"rf\x02\x8d\x972\x14\xedg\xe1\xe4\x89\x87\x9f\xfdf" +
|
|
"\xfa\xe6\xb3\xbf\xee\xe5\xd6h\xb6\xd0\x14\x1a2\xfc4\xb5" +
|
|
"+\x0c0\x18\xfc\xf1g~8Z\xbf\xf1zOlF" +
|
|
"\x01\xa7\xb2\xb7\x8d/g\xe9k.{\x180`7\xcd" +
|
|
"\x8d'~\xf7\xf97\x13\xfbw-\xfbg\x84T0\xfd" +
|
|
"\xa5\x87\x97\xfa\x8e\xbd\xf5Vr\xff.g\xc3\x14^\xca" +
|
|
"\xd2\xfe=p`D\xee\xdf\xb9\xefm\xd0\x07\xf9\xbbN" +
|
|
"\xf1Fv\x08\x8d\xbf\x11\xc9\x8e\x9bY\x0d\x8d\xf3\xfd\x1a" +
|
|
"@\xf0\xf4\xe3c{\x1f\xdct\xfdv2\xde\xb1\xfe\xdb" +
|
|
"\x14\xefl?\xc5\x9b\xdf\xf9\xf7/|\xf4\xe9_\xdd\xee" +
|
|
"\x91\x1dN\xbc\xd6\xbf\x05\x8d\xeb\x14\xc7x\x95&\xdf\xda" +
|
|
"\xfd\xbd\xdf\x0e\xe6\x07\xff\xd9st\xa1\xfe?\xf5/\xa1" +
|
|
"\xf1\xaf\xfep\xcb\xfb\x8b\x08\x18\x1c\xbd\xf5\xdc\x9e3\xfb" +
|
|
"\xaf\xfe7I\xfd\x91\xdc\xcbD\xbd=G\xd4K\xe7\x8f" +
|
|
"z{\xbe\xfd\x8d`\x95\x1d\xdb!r\xa3h\x989\xa2" +
|
|
"~$w\x18\xb6\x06\x9eo\xdb\xb2\xa1Z\xa9\xda'\xa2" +
|
|
"\xcf\xda}5\xb3e\xb7\x86\xc6\x8fX\xaeg\xd9\x0b\xb3" +
|
|
"!^\xaa8\x0d\xab\xb6\\A\x14\xeb\x91\x01\xe8w\x0f" +
|
|
"\x01 \xea\x1b\x1e\x02@\xa6\xeb\xa3\x00%k\xc1v\x94" +
|
|
"\x0c\xea\x96[sl[\x02\xafy\xc7\x0f\x9a\x0d\xd3\xae" +
|
|
"\xc9\x98(\xb3\x92\xa8MP\x95\xea\x90T\xf7\xf9\xb6\x92" +
|
|
"\x0b\x96\xebI\xd5\x867\x97*\xa62\x9b\xaeH\xf1\x14" +
|
|
"@\x0a\x01\xf4\xdc\x05\x001\xc0Q|\x98a\xb0\xa0\xcc" +
|
|
"\x9a\xacH\x85\x96S\x9f6m\xa7\xcae\x0d\xd3\xc00" +
|
|
"\x0d\x18\x93\xe6\xde/\xe9\x8ct\xfd\x86\xe7B\xbc\xea\xce" +
|
|
"\xeb\xc3tk\xde\xe6Jq\x85\xd6\x87\x00\xc4z\x8e\xe2" +
|
|
".\x86A\x8bF\xa5'\x81+\x17\x07\xbaw\x16\x10\x07" +
|
|
"\x12j\xd3+\xd9v\xd1\xdf]m\x96J'\x8ar\x01" +
|
|
"\xe88\x06b2\x93\xc8\x0ep\x14\x0d\x86:b\x81\\" +
|
|
"F\xb7\x14\x80X\xe4(<\x86\xc8\x0a\xe1\xd9=z\x09" +
|
|
"@x\x1c\xc5\x09\x86:g\x05\xe4\x00\xfa\xb1-\x00\xe2" +
|
|
"\x08Gq\x8ea\xe0(k\xc1\xb2w\x91T\x0fs\xc0" +
|
|
"0\x07\x18\xd4\x1a\x8e_\x9fo\x98PT\xb2^\x1e\x8b" +
|
|
"q\xdboV\x94<d\xa1\xe3\xbb#\x9e'\x9bZ\xcb" +
|
|
"s1\x03\x0c3\x80y\xcf\\p\xf1C\x80\x15\x8e8" +
|
|
"\xd0\xbd\xcf\x80\x04\xc6I\xf3U\x92\x0e\xf3-y\xe3J" +
|
|
"9*,\xbc8\xd3\xf1\xfb\x01\xc40G1\xc90J" +
|
|
"\xb4L\xd9\xef\xe1(f\x19\xeal\xb8\x9d\xa98\x08 " +
|
|
"*\x1c\xc5~\x86\xc5\x9a\xe9\xbb\x12\xd7\x03\xc3\xf5\x80\x81" +
|
|
"\x92\x9eZ\x1e\x99\xf7\x80K\x15W\x8c\xbb\xe8\xf8\x8d\xfa" +
|
|
"\x8c\x04\xcdS\xcb\x88\xc0\x10\x13\"\xd7*\xde\x9e*\xaa" +
|
|
"\x98\xf9\xb0\x1c\x12\xbaI\xe3\x18GQI\x9c\xd0\xd4\x04" +
|
|
"\x80\x98\xe4(\xf6\x91\xf0\xce\x11\xcd\x8dv\x85\xaf~\x1a" +
|
|
"\x8b\x8e\xeb\xd9fS\x02@\x94\xd3q\xa7\xe5Y\x8eM" +
|
|
"\xc5\x15\xdblOq\xadr\xd1G|oQ\xda\x9eU" +
|
|
"3iq\xbb\xa8\x12\x927u\xb7:\x96\\\xbe?\x91" +
|
|
"G$y\xea`7\x0f\xed+r9RU\x94M\xd3" +
|
|
"j\xc4\xfb\xdeIf\x04\xb4/v\xe7\xdcI\xdfL\xb8" +
|
|
"\xab*T\xb7\xb7U\x0c3$\x8d\xdb\"\x8d\xc6\x08N" +
|
|
"\x00T\x87\x91cu\x12\xbb2\x8d2\x8e\x02T\xc7\x08" +
|
|
"\xaf`W\xa91\x85\x83\x00\xd5=\x84\xcf\"C\xe4\xe1" +
|
|
"\x0d0\x04\xfe\x00\xa0:K\xf0\x01\x9a\x9e\xe2\x05L\x91" +
|
|
"U\x86\xe1\xf7\x13\xbeHx:U\xc04\x80!q\x0b" +
|
|
"@\xf5\x00\xe1G\x09\xcf\xb0\x02f\x00\x8ce\\\x02\xa8" +
|
|
"\x1e!\xfc\x14\xe1Z\xba@6m<\x81\x0a\xa0z\x82" +
|
|
"\xf0\xa7\x08_wW\x01\xd7\x01\x18_\x0f\xf1'\x09?" +
|
|
"Gx\xdf\xc6\x02\xf6\x01\x18g\xf1$@\xf5\x19\xc2\x9f" +
|
|
"'<\x8b\x05\xcc\x02\x18\xcf\xe1\x05\x80\xea\xf3\x84\xbf@" +
|
|
"x\x7f\xa6\x80\xfd\x00\xc6\xe5P\xcfE\xc2\xaf\"\xa3\xfb" +
|
|
"jI\xdb+\xd7\x93\x15rH*\xd7r\xec\xe8\x7f\xee" +
|
|
"\xb8\xf1\x11\xc8\x8e\xe1c\xbb|+N\x9e\x1c\x1f\xf3\xdd" +
|
|
"\x16\x07\x10\xf3\x80A\xcbq\x1a\xd3\xef\xae\xbc5ny" +
|
|
"\xc7 -\xc8;v\xb9\x1eYC\xa7\x14&\x1d(\xd6" +
|
|
"\xccF\xb9\x15+\xb1\xdc\x11\xdfs\xfc\x16\x14\xeb\xa6'" +
|
|
"\xeb\xf1=T\xbe\xbd[9\xcdY\x94\xaai\xd9f\x03" +
|
|
"\xe2\x91\x9a\xd3l)\xe9\xbah9\xb6\xf0\xcd\x86\xc5\xbd" +
|
|
"e\xec\x03\x86}\x80y\xdf\xb7\xea+\x0a\x8d\xf5\x16Z" +
|
|
"\xb154k.Pa\xad\x8b\x8b\xff\xe3\xe4\x89\x9b9" +
|
|
"\x8am\x89\xe2\xdfJ\xc5\xff1\x8e\xe2\x93\x0c\xf3t\x03" +
|
|
"\xe3B?d6|\xb9\x82i-\xd7X\x90^\xfb\xab" +
|
|
"l\xcf;\x9b+\xa6\xd2\xcc\xa6\xfb\x01W\xcfH7O" +
|
|
"/W\xf2\x09\x1a\x02\x10\xeb8\x8a\x02\xc3\x92\x0a\x1f6" +
|
|
"\x1c\xe86(=\xfe\xc0\xff\x1f]\xa9\xcd\xd2~q\xd2" +
|
|
"\x00q[\x88Q3\xa4?\xfa\x180\xdd\xd2\xb0\xdb\x89" +
|
|
"a\xd4x\xe9\x8f(`\xfa\x9c\x86,n\x831jw" +
|
|
"\xf5\xf2i`\xfa\xb8\x86<\xees1\xear\xf4\x07G" +
|
|
"\x81\xe9[\xb5 \xb2V(\xb5\xe5\x0cc\x10e\x0e\xc5" +
|
|
"0\xf7a\x0c\xa2w\x1c#\x0b\x06\x18\xc6\xe3\x9d\xe2\x1b" +
|
|
"\xc6\x0a~`+\x9f\x91E\xf7\xbd\xeck\xd4\xcb\xad\xbd" +
|
|
"\xabm\x9e<)\xa7=M\xc4]J\xb4\x0c\x0d\xa7\xe3" +
|
|
"\xca\xf9\xe9D\xa1\xdd\xc9-\xdb\x82#\xcf\xcc\xd3b\x8a" +
|
|
"_\x88\xe3\x1f\xdb\xd4y\xe7O%j\xfa\x09\x02\x8fr" +
|
|
"\x14O&\x0c\xfd\xab\xf40\x9d\xe2(.\xc6\x1e\xa9\x7f" +
|
|
"\xf74\x80\xb8\xc8Q\\\xed\x1a\xa4\xfe}\x9a\xf8\x02G" +
|
|
"\xf1S\x86\x9aT*\xd2\xa9\xf9\xaa\xeb\xfb\x0dga\xd2" +
|
|
"\xb2\xa5K\xae\xd11\x0a\x1a\"{hI\xd54mi" +
|
|
"\xa3\xb7\xdb\xb4\x1a\xbe\x92\x00=ooy,a6w" +
|
|
"\xea\x94V\xed\xcbfJ\xf2=\x9d^\xb7w^\xfb\xd5" +
|
|
"\xectc\xedN\x11zlc\xd3j\xb6Ao\xff\xbd" +
|
|
"\x1c\xc5\xce\xce&\x0dt\x7f\x87u\xe8\xdc\xceE\x06>" +
|
|
"\xef\xac\xbc\xa3\xff\x0b\x00\x00\xff\xffR\x8f\xce\x88"
|
|
|
|
func init() {
|
|
schemas.Register(schema_db8274f9144abc7e,
|
|
0x84cb9536a2cf6d3c,
|
|
0x9b87b390babc2ccf,
|
|
0xa29a916d4ebdd894,
|
|
0xa766b24d4fe5da35,
|
|
0xa78f37418c1077c8,
|
|
0xb14ce48f4e2abb0d,
|
|
0xb70431c0dc014915,
|
|
0xc082ef6e0d42ed1d,
|
|
0xc793e50592935b4a,
|
|
0xcbd96442ae3bb01a,
|
|
0xdc3ed6801961e502,
|
|
0xe3e37d096a5b564e,
|
|
0xea58385c65416035,
|
|
0xf2c122394f447e8e,
|
|
0xf2c68e2547ec3866,
|
|
0xf41a0f001ad49e46,
|
|
0xfeac5c8f4899ef7c,
|
|
0xff8d9848747c956a)
|
|
}
|