4845 lines
180 KiB
Go
4845 lines
180 KiB
Go
// Code generated by capnpc-go. DO NOT EDIT.
|
|
|
|
package proto
|
|
|
|
import (
|
|
strconv "strconv"
|
|
|
|
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) }
|
|
|
|
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: 6})
|
|
return TunnelRegistration{st}, err
|
|
}
|
|
|
|
func NewRootTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 6})
|
|
return TunnelRegistration{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelRegistration(msg *capnp.Message) (TunnelRegistration, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelRegistration{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelRegistration) String() string {
|
|
str, _ := text.Marshal(0xf41a0f001ad49e46, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelRegistration) Err() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) HasErr() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelRegistration) ErrBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) SetErr(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s TunnelRegistration) Url() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) HasUrl() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelRegistration) UrlBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) SetUrl(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s TunnelRegistration) LogLines() (capnp.TextList, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return capnp.TextList{List: p.List()}, err
|
|
}
|
|
|
|
func (s TunnelRegistration) HasLogLines() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelRegistration) SetLogLines(v capnp.TextList) error {
|
|
return s.Struct.SetPtr(2, v.List.ToPtr())
|
|
}
|
|
|
|
// NewLogLines sets the logLines field to a newly
|
|
// allocated capnp.TextList, preferring placement in s's segment.
|
|
func (s TunnelRegistration) NewLogLines(n int32) (capnp.TextList, error) {
|
|
l, err := capnp.NewTextList(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return capnp.TextList{}, err
|
|
}
|
|
err = s.Struct.SetPtr(2, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
func (s TunnelRegistration) PermanentFailure() bool {
|
|
return s.Struct.Bit(0)
|
|
}
|
|
|
|
func (s TunnelRegistration) SetPermanentFailure(v bool) {
|
|
s.Struct.SetBit(0, v)
|
|
}
|
|
|
|
func (s TunnelRegistration) TunnelID() (string, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) HasTunnelID() bool {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelRegistration) TunnelIDBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) SetTunnelID(v string) error {
|
|
return s.Struct.SetText(3, v)
|
|
}
|
|
|
|
func (s TunnelRegistration) RetryAfterSeconds() uint16 {
|
|
return s.Struct.Uint16(2)
|
|
}
|
|
|
|
func (s TunnelRegistration) SetRetryAfterSeconds(v uint16) {
|
|
s.Struct.SetUint16(2, v)
|
|
}
|
|
|
|
func (s TunnelRegistration) EventDigest() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(4)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s TunnelRegistration) HasEventDigest() bool {
|
|
p, err := s.Struct.Ptr(4)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelRegistration) SetEventDigest(v []byte) error {
|
|
return s.Struct.SetData(4, v)
|
|
}
|
|
|
|
func (s TunnelRegistration) ConnDigest() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(5)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s TunnelRegistration) HasConnDigest() bool {
|
|
p, err := s.Struct.Ptr(5)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelRegistration) SetConnDigest(v []byte) error {
|
|
return s.Struct.SetData(5, 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: 6}, 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: 8})
|
|
return RegistrationOptions{st}, err
|
|
}
|
|
|
|
func NewRootRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 8})
|
|
return RegistrationOptions{st}, err
|
|
}
|
|
|
|
func ReadRootRegistrationOptions(msg *capnp.Message) (RegistrationOptions, error) {
|
|
root, err := msg.RootPtr()
|
|
return RegistrationOptions{root.Struct()}, err
|
|
}
|
|
|
|
func (s RegistrationOptions) String() string {
|
|
str, _ := text.Marshal(0xc793e50592935b4a, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s RegistrationOptions) ClientId() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasClientId() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) ClientIdBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetClientId(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) Version() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasVersion() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) VersionBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetVersion(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) Os() (string, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasOs() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) OsBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetOs(v string) error {
|
|
return s.Struct.SetText(2, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) ExistingTunnelPolicy() ExistingTunnelPolicy {
|
|
return ExistingTunnelPolicy(s.Struct.Uint16(0))
|
|
}
|
|
|
|
func (s RegistrationOptions) SetExistingTunnelPolicy(v ExistingTunnelPolicy) {
|
|
s.Struct.SetUint16(0, uint16(v))
|
|
}
|
|
|
|
func (s RegistrationOptions) PoolName() (string, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasPoolName() bool {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) PoolNameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetPoolName(v string) error {
|
|
return s.Struct.SetText(3, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) Tags() (Tag_List, error) {
|
|
p, err := s.Struct.Ptr(4)
|
|
return Tag_List{List: p.List()}, err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasTags() bool {
|
|
p, err := s.Struct.Ptr(4)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) SetTags(v Tag_List) error {
|
|
return s.Struct.SetPtr(4, v.List.ToPtr())
|
|
}
|
|
|
|
// NewTags sets the tags field to a newly
|
|
// allocated Tag_List, preferring placement in s's segment.
|
|
func (s RegistrationOptions) NewTags(n int32) (Tag_List, error) {
|
|
l, err := NewTag_List(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return Tag_List{}, err
|
|
}
|
|
err = s.Struct.SetPtr(4, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
func (s RegistrationOptions) ConnectionId() uint8 {
|
|
return s.Struct.Uint8(2)
|
|
}
|
|
|
|
func (s RegistrationOptions) SetConnectionId(v uint8) {
|
|
s.Struct.SetUint8(2, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) OriginLocalIp() (string, error) {
|
|
p, err := s.Struct.Ptr(5)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasOriginLocalIp() bool {
|
|
p, err := s.Struct.Ptr(5)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) OriginLocalIpBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(5)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetOriginLocalIp(v string) error {
|
|
return s.Struct.SetText(5, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) IsAutoupdated() bool {
|
|
return s.Struct.Bit(24)
|
|
}
|
|
|
|
func (s RegistrationOptions) SetIsAutoupdated(v bool) {
|
|
s.Struct.SetBit(24, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) RunFromTerminal() bool {
|
|
return s.Struct.Bit(25)
|
|
}
|
|
|
|
func (s RegistrationOptions) SetRunFromTerminal(v bool) {
|
|
s.Struct.SetBit(25, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) CompressionQuality() uint64 {
|
|
return s.Struct.Uint64(8)
|
|
}
|
|
|
|
func (s RegistrationOptions) SetCompressionQuality(v uint64) {
|
|
s.Struct.SetUint64(8, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) Uuid() (string, error) {
|
|
p, err := s.Struct.Ptr(6)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasUuid() bool {
|
|
p, err := s.Struct.Ptr(6)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) UuidBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(6)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetUuid(v string) error {
|
|
return s.Struct.SetText(6, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) NumPreviousAttempts() uint8 {
|
|
return s.Struct.Uint8(4)
|
|
}
|
|
|
|
func (s RegistrationOptions) SetNumPreviousAttempts(v uint8) {
|
|
s.Struct.SetUint8(4, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) Features() (capnp.TextList, error) {
|
|
p, err := s.Struct.Ptr(7)
|
|
return capnp.TextList{List: p.List()}, err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasFeatures() bool {
|
|
p, err := s.Struct.Ptr(7)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) SetFeatures(v capnp.TextList) error {
|
|
return s.Struct.SetPtr(7, v.List.ToPtr())
|
|
}
|
|
|
|
// NewFeatures sets the features field to a newly
|
|
// allocated capnp.TextList, preferring placement in s's segment.
|
|
func (s RegistrationOptions) NewFeatures(n int32) (capnp.TextList, error) {
|
|
l, err := capnp.NewTextList(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return capnp.TextList{}, err
|
|
}
|
|
err = s.Struct.SetPtr(7, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
// RegistrationOptions_List is a list of RegistrationOptions.
|
|
type RegistrationOptions_List struct{ capnp.List }
|
|
|
|
// NewRegistrationOptions creates a new list of RegistrationOptions.
|
|
func NewRegistrationOptions_List(s *capnp.Segment, sz int32) (RegistrationOptions_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 8}, sz)
|
|
return RegistrationOptions_List{l}, err
|
|
}
|
|
|
|
func (s RegistrationOptions_List) At(i int) RegistrationOptions {
|
|
return RegistrationOptions{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s RegistrationOptions_List) Set(i int, v RegistrationOptions) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
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 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 AuthenticateResponse struct{ capnp.Struct }
|
|
|
|
// AuthenticateResponse_TypeID is the unique identifier for the type AuthenticateResponse.
|
|
const AuthenticateResponse_TypeID = 0x82c325a07ad22a65
|
|
|
|
func NewAuthenticateResponse(s *capnp.Segment) (AuthenticateResponse, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
|
|
return AuthenticateResponse{st}, err
|
|
}
|
|
|
|
func NewRootAuthenticateResponse(s *capnp.Segment) (AuthenticateResponse, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
|
|
return AuthenticateResponse{st}, err
|
|
}
|
|
|
|
func ReadRootAuthenticateResponse(msg *capnp.Message) (AuthenticateResponse, error) {
|
|
root, err := msg.RootPtr()
|
|
return AuthenticateResponse{root.Struct()}, err
|
|
}
|
|
|
|
func (s AuthenticateResponse) String() string {
|
|
str, _ := text.Marshal(0x82c325a07ad22a65, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s AuthenticateResponse) PermanentErr() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s AuthenticateResponse) HasPermanentErr() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s AuthenticateResponse) PermanentErrBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s AuthenticateResponse) SetPermanentErr(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s AuthenticateResponse) RetryableErr() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s AuthenticateResponse) HasRetryableErr() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s AuthenticateResponse) RetryableErrBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s AuthenticateResponse) SetRetryableErr(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s AuthenticateResponse) Jwt() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s AuthenticateResponse) HasJwt() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s AuthenticateResponse) SetJwt(v []byte) error {
|
|
return s.Struct.SetData(2, v)
|
|
}
|
|
|
|
func (s AuthenticateResponse) HoursUntilRefresh() uint8 {
|
|
return s.Struct.Uint8(0)
|
|
}
|
|
|
|
func (s AuthenticateResponse) SetHoursUntilRefresh(v uint8) {
|
|
s.Struct.SetUint8(0, v)
|
|
}
|
|
|
|
// AuthenticateResponse_List is a list of AuthenticateResponse.
|
|
type AuthenticateResponse_List struct{ capnp.List }
|
|
|
|
// NewAuthenticateResponse creates a new list of AuthenticateResponse.
|
|
func NewAuthenticateResponse_List(s *capnp.Segment, sz int32) (AuthenticateResponse_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}, sz)
|
|
return AuthenticateResponse_List{l}, err
|
|
}
|
|
|
|
func (s AuthenticateResponse_List) At(i int) AuthenticateResponse {
|
|
return AuthenticateResponse{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s AuthenticateResponse_List) Set(i int, v AuthenticateResponse) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s AuthenticateResponse_List) String() string {
|
|
str, _ := text.MarshalList(0x82c325a07ad22a65, s.List)
|
|
return str
|
|
}
|
|
|
|
// AuthenticateResponse_Promise is a wrapper for a AuthenticateResponse promised by a client call.
|
|
type AuthenticateResponse_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p AuthenticateResponse_Promise) Struct() (AuthenticateResponse, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return AuthenticateResponse{s}, err
|
|
}
|
|
|
|
type ClientInfo struct{ capnp.Struct }
|
|
|
|
// ClientInfo_TypeID is the unique identifier for the type ClientInfo.
|
|
const ClientInfo_TypeID = 0x83ced0145b2f114b
|
|
|
|
func NewClientInfo(s *capnp.Segment) (ClientInfo, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 4})
|
|
return ClientInfo{st}, err
|
|
}
|
|
|
|
func NewRootClientInfo(s *capnp.Segment) (ClientInfo, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 4})
|
|
return ClientInfo{st}, err
|
|
}
|
|
|
|
func ReadRootClientInfo(msg *capnp.Message) (ClientInfo, error) {
|
|
root, err := msg.RootPtr()
|
|
return ClientInfo{root.Struct()}, err
|
|
}
|
|
|
|
func (s ClientInfo) String() string {
|
|
str, _ := text.Marshal(0x83ced0145b2f114b, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ClientInfo) ClientId() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s ClientInfo) HasClientId() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ClientInfo) SetClientId(v []byte) error {
|
|
return s.Struct.SetData(0, v)
|
|
}
|
|
|
|
func (s ClientInfo) Features() (capnp.TextList, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return capnp.TextList{List: p.List()}, err
|
|
}
|
|
|
|
func (s ClientInfo) HasFeatures() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ClientInfo) SetFeatures(v capnp.TextList) error {
|
|
return s.Struct.SetPtr(1, v.List.ToPtr())
|
|
}
|
|
|
|
// NewFeatures sets the features field to a newly
|
|
// allocated capnp.TextList, preferring placement in s's segment.
|
|
func (s ClientInfo) NewFeatures(n int32) (capnp.TextList, error) {
|
|
l, err := capnp.NewTextList(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return capnp.TextList{}, err
|
|
}
|
|
err = s.Struct.SetPtr(1, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
func (s ClientInfo) Version() (string, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s ClientInfo) HasVersion() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ClientInfo) VersionBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s ClientInfo) SetVersion(v string) error {
|
|
return s.Struct.SetText(2, v)
|
|
}
|
|
|
|
func (s ClientInfo) Arch() (string, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s ClientInfo) HasArch() bool {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ClientInfo) ArchBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s ClientInfo) SetArch(v string) error {
|
|
return s.Struct.SetText(3, v)
|
|
}
|
|
|
|
// ClientInfo_List is a list of ClientInfo.
|
|
type ClientInfo_List struct{ capnp.List }
|
|
|
|
// NewClientInfo creates a new list of ClientInfo.
|
|
func NewClientInfo_List(s *capnp.Segment, sz int32) (ClientInfo_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 4}, sz)
|
|
return ClientInfo_List{l}, err
|
|
}
|
|
|
|
func (s ClientInfo_List) At(i int) ClientInfo { return ClientInfo{s.List.Struct(i)} }
|
|
|
|
func (s ClientInfo_List) Set(i int, v ClientInfo) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
func (s ClientInfo_List) String() string {
|
|
str, _ := text.MarshalList(0x83ced0145b2f114b, s.List)
|
|
return str
|
|
}
|
|
|
|
// ClientInfo_Promise is a wrapper for a ClientInfo promised by a client call.
|
|
type ClientInfo_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ClientInfo_Promise) Struct() (ClientInfo, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ClientInfo{s}, err
|
|
}
|
|
|
|
type ConnectionOptions struct{ capnp.Struct }
|
|
|
|
// ConnectionOptions_TypeID is the unique identifier for the type ConnectionOptions.
|
|
const ConnectionOptions_TypeID = 0xb4bf9861fe035d04
|
|
|
|
func NewConnectionOptions(s *capnp.Segment) (ConnectionOptions, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
|
|
return ConnectionOptions{st}, err
|
|
}
|
|
|
|
func NewRootConnectionOptions(s *capnp.Segment) (ConnectionOptions, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
|
|
return ConnectionOptions{st}, err
|
|
}
|
|
|
|
func ReadRootConnectionOptions(msg *capnp.Message) (ConnectionOptions, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConnectionOptions{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectionOptions) String() string {
|
|
str, _ := text.Marshal(0xb4bf9861fe035d04, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConnectionOptions) Client() (ClientInfo, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return ClientInfo{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectionOptions) HasClient() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectionOptions) SetClient(v ClientInfo) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewClient sets the client field to a newly
|
|
// allocated ClientInfo struct, preferring placement in s's segment.
|
|
func (s ConnectionOptions) NewClient() (ClientInfo, error) {
|
|
ss, err := NewClientInfo(s.Struct.Segment())
|
|
if err != nil {
|
|
return ClientInfo{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ConnectionOptions) OriginLocalIp() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s ConnectionOptions) HasOriginLocalIp() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectionOptions) SetOriginLocalIp(v []byte) error {
|
|
return s.Struct.SetData(1, v)
|
|
}
|
|
|
|
func (s ConnectionOptions) ReplaceExisting() bool {
|
|
return s.Struct.Bit(0)
|
|
}
|
|
|
|
func (s ConnectionOptions) SetReplaceExisting(v bool) {
|
|
s.Struct.SetBit(0, v)
|
|
}
|
|
|
|
func (s ConnectionOptions) CompressionQuality() uint8 {
|
|
return s.Struct.Uint8(1)
|
|
}
|
|
|
|
func (s ConnectionOptions) SetCompressionQuality(v uint8) {
|
|
s.Struct.SetUint8(1, v)
|
|
}
|
|
|
|
func (s ConnectionOptions) NumPreviousAttempts() uint8 {
|
|
return s.Struct.Uint8(2)
|
|
}
|
|
|
|
func (s ConnectionOptions) SetNumPreviousAttempts(v uint8) {
|
|
s.Struct.SetUint8(2, v)
|
|
}
|
|
|
|
// ConnectionOptions_List is a list of ConnectionOptions.
|
|
type ConnectionOptions_List struct{ capnp.List }
|
|
|
|
// NewConnectionOptions creates a new list of ConnectionOptions.
|
|
func NewConnectionOptions_List(s *capnp.Segment, sz int32) (ConnectionOptions_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
|
|
return ConnectionOptions_List{l}, err
|
|
}
|
|
|
|
func (s ConnectionOptions_List) At(i int) ConnectionOptions {
|
|
return ConnectionOptions{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s ConnectionOptions_List) Set(i int, v ConnectionOptions) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s ConnectionOptions_List) String() string {
|
|
str, _ := text.MarshalList(0xb4bf9861fe035d04, s.List)
|
|
return str
|
|
}
|
|
|
|
// ConnectionOptions_Promise is a wrapper for a ConnectionOptions promised by a client call.
|
|
type ConnectionOptions_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConnectionOptions_Promise) Struct() (ConnectionOptions, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConnectionOptions{s}, err
|
|
}
|
|
|
|
func (p ConnectionOptions_Promise) Client() ClientInfo_Promise {
|
|
return ClientInfo_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type ConnectionResponse struct{ capnp.Struct }
|
|
type ConnectionResponse_result ConnectionResponse
|
|
type ConnectionResponse_result_Which uint16
|
|
|
|
const (
|
|
ConnectionResponse_result_Which_error ConnectionResponse_result_Which = 0
|
|
ConnectionResponse_result_Which_connectionDetails ConnectionResponse_result_Which = 1
|
|
)
|
|
|
|
func (w ConnectionResponse_result_Which) String() string {
|
|
const s = "errorconnectionDetails"
|
|
switch w {
|
|
case ConnectionResponse_result_Which_error:
|
|
return s[0:5]
|
|
case ConnectionResponse_result_Which_connectionDetails:
|
|
return s[5:22]
|
|
|
|
}
|
|
return "ConnectionResponse_result_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
|
|
}
|
|
|
|
// ConnectionResponse_TypeID is the unique identifier for the type ConnectionResponse.
|
|
const ConnectionResponse_TypeID = 0xdbaa9d03d52b62dc
|
|
|
|
func NewConnectionResponse(s *capnp.Segment) (ConnectionResponse, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
|
|
return ConnectionResponse{st}, err
|
|
}
|
|
|
|
func NewRootConnectionResponse(s *capnp.Segment) (ConnectionResponse, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
|
|
return ConnectionResponse{st}, err
|
|
}
|
|
|
|
func ReadRootConnectionResponse(msg *capnp.Message) (ConnectionResponse, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConnectionResponse{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectionResponse) String() string {
|
|
str, _ := text.Marshal(0xdbaa9d03d52b62dc, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConnectionResponse) Result() ConnectionResponse_result { return ConnectionResponse_result(s) }
|
|
|
|
func (s ConnectionResponse_result) Which() ConnectionResponse_result_Which {
|
|
return ConnectionResponse_result_Which(s.Struct.Uint16(0))
|
|
}
|
|
func (s ConnectionResponse_result) Error() (ConnectionError, error) {
|
|
if s.Struct.Uint16(0) != 0 {
|
|
panic("Which() != error")
|
|
}
|
|
p, err := s.Struct.Ptr(0)
|
|
return ConnectionError{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectionResponse_result) HasError() bool {
|
|
if s.Struct.Uint16(0) != 0 {
|
|
return false
|
|
}
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectionResponse_result) SetError(v ConnectionError) error {
|
|
s.Struct.SetUint16(0, 0)
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewError sets the error field to a newly
|
|
// allocated ConnectionError struct, preferring placement in s's segment.
|
|
func (s ConnectionResponse_result) NewError() (ConnectionError, error) {
|
|
s.Struct.SetUint16(0, 0)
|
|
ss, err := NewConnectionError(s.Struct.Segment())
|
|
if err != nil {
|
|
return ConnectionError{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ConnectionResponse_result) ConnectionDetails() (ConnectionDetails, error) {
|
|
if s.Struct.Uint16(0) != 1 {
|
|
panic("Which() != connectionDetails")
|
|
}
|
|
p, err := s.Struct.Ptr(0)
|
|
return ConnectionDetails{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectionResponse_result) HasConnectionDetails() bool {
|
|
if s.Struct.Uint16(0) != 1 {
|
|
return false
|
|
}
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectionResponse_result) SetConnectionDetails(v ConnectionDetails) error {
|
|
s.Struct.SetUint16(0, 1)
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewConnectionDetails sets the connectionDetails field to a newly
|
|
// allocated ConnectionDetails struct, preferring placement in s's segment.
|
|
func (s ConnectionResponse_result) NewConnectionDetails() (ConnectionDetails, error) {
|
|
s.Struct.SetUint16(0, 1)
|
|
ss, err := NewConnectionDetails(s.Struct.Segment())
|
|
if err != nil {
|
|
return ConnectionDetails{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// ConnectionResponse_List is a list of ConnectionResponse.
|
|
type ConnectionResponse_List struct{ capnp.List }
|
|
|
|
// NewConnectionResponse creates a new list of ConnectionResponse.
|
|
func NewConnectionResponse_List(s *capnp.Segment, sz int32) (ConnectionResponse_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
|
|
return ConnectionResponse_List{l}, err
|
|
}
|
|
|
|
func (s ConnectionResponse_List) At(i int) ConnectionResponse {
|
|
return ConnectionResponse{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s ConnectionResponse_List) Set(i int, v ConnectionResponse) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s ConnectionResponse_List) String() string {
|
|
str, _ := text.MarshalList(0xdbaa9d03d52b62dc, s.List)
|
|
return str
|
|
}
|
|
|
|
// ConnectionResponse_Promise is a wrapper for a ConnectionResponse promised by a client call.
|
|
type ConnectionResponse_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConnectionResponse_Promise) Struct() (ConnectionResponse, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConnectionResponse{s}, err
|
|
}
|
|
|
|
func (p ConnectionResponse_Promise) Result() ConnectionResponse_result_Promise {
|
|
return ConnectionResponse_result_Promise{p.Pipeline}
|
|
}
|
|
|
|
// ConnectionResponse_result_Promise is a wrapper for a ConnectionResponse_result promised by a client call.
|
|
type ConnectionResponse_result_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConnectionResponse_result_Promise) Struct() (ConnectionResponse_result, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConnectionResponse_result{s}, err
|
|
}
|
|
|
|
func (p ConnectionResponse_result_Promise) Error() ConnectionError_Promise {
|
|
return ConnectionError_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
func (p ConnectionResponse_result_Promise) ConnectionDetails() ConnectionDetails_Promise {
|
|
return ConnectionDetails_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type ConnectionError struct{ capnp.Struct }
|
|
|
|
// ConnectionError_TypeID is the unique identifier for the type ConnectionError.
|
|
const ConnectionError_TypeID = 0xf5f383d2785edb86
|
|
|
|
func NewConnectionError(s *capnp.Segment) (ConnectionError, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
|
|
return ConnectionError{st}, err
|
|
}
|
|
|
|
func NewRootConnectionError(s *capnp.Segment) (ConnectionError, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
|
|
return ConnectionError{st}, err
|
|
}
|
|
|
|
func ReadRootConnectionError(msg *capnp.Message) (ConnectionError, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConnectionError{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectionError) String() string {
|
|
str, _ := text.Marshal(0xf5f383d2785edb86, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConnectionError) Cause() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s ConnectionError) HasCause() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectionError) CauseBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s ConnectionError) SetCause(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s ConnectionError) RetryAfter() int64 {
|
|
return int64(s.Struct.Uint64(0))
|
|
}
|
|
|
|
func (s ConnectionError) SetRetryAfter(v int64) {
|
|
s.Struct.SetUint64(0, uint64(v))
|
|
}
|
|
|
|
func (s ConnectionError) ShouldRetry() bool {
|
|
return s.Struct.Bit(64)
|
|
}
|
|
|
|
func (s ConnectionError) SetShouldRetry(v bool) {
|
|
s.Struct.SetBit(64, v)
|
|
}
|
|
|
|
// ConnectionError_List is a list of ConnectionError.
|
|
type ConnectionError_List struct{ capnp.List }
|
|
|
|
// NewConnectionError creates a new list of ConnectionError.
|
|
func NewConnectionError_List(s *capnp.Segment, sz int32) (ConnectionError_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}, sz)
|
|
return ConnectionError_List{l}, err
|
|
}
|
|
|
|
func (s ConnectionError_List) At(i int) ConnectionError { return ConnectionError{s.List.Struct(i)} }
|
|
|
|
func (s ConnectionError_List) Set(i int, v ConnectionError) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s ConnectionError_List) String() string {
|
|
str, _ := text.MarshalList(0xf5f383d2785edb86, s.List)
|
|
return str
|
|
}
|
|
|
|
// ConnectionError_Promise is a wrapper for a ConnectionError promised by a client call.
|
|
type ConnectionError_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConnectionError_Promise) Struct() (ConnectionError, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConnectionError{s}, err
|
|
}
|
|
|
|
type ConnectionDetails struct{ capnp.Struct }
|
|
|
|
// ConnectionDetails_TypeID is the unique identifier for the type ConnectionDetails.
|
|
const ConnectionDetails_TypeID = 0xb5f39f082b9ac18a
|
|
|
|
func NewConnectionDetails(s *capnp.Segment) (ConnectionDetails, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
|
|
return ConnectionDetails{st}, err
|
|
}
|
|
|
|
func NewRootConnectionDetails(s *capnp.Segment) (ConnectionDetails, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
|
|
return ConnectionDetails{st}, err
|
|
}
|
|
|
|
func ReadRootConnectionDetails(msg *capnp.Message) (ConnectionDetails, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConnectionDetails{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectionDetails) String() string {
|
|
str, _ := text.Marshal(0xb5f39f082b9ac18a, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConnectionDetails) Uuid() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s ConnectionDetails) HasUuid() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectionDetails) SetUuid(v []byte) error {
|
|
return s.Struct.SetData(0, v)
|
|
}
|
|
|
|
func (s ConnectionDetails) LocationName() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s ConnectionDetails) HasLocationName() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectionDetails) LocationNameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s ConnectionDetails) SetLocationName(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s ConnectionDetails) TunnelIsRemotelyManaged() bool {
|
|
return s.Struct.Bit(0)
|
|
}
|
|
|
|
func (s ConnectionDetails) SetTunnelIsRemotelyManaged(v bool) {
|
|
s.Struct.SetBit(0, v)
|
|
}
|
|
|
|
// ConnectionDetails_List is a list of ConnectionDetails.
|
|
type ConnectionDetails_List struct{ capnp.List }
|
|
|
|
// NewConnectionDetails creates a new list of ConnectionDetails.
|
|
func NewConnectionDetails_List(s *capnp.Segment, sz int32) (ConnectionDetails_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
|
|
return ConnectionDetails_List{l}, err
|
|
}
|
|
|
|
func (s ConnectionDetails_List) At(i int) ConnectionDetails {
|
|
return ConnectionDetails{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s ConnectionDetails_List) Set(i int, v ConnectionDetails) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s ConnectionDetails_List) String() string {
|
|
str, _ := text.MarshalList(0xb5f39f082b9ac18a, s.List)
|
|
return str
|
|
}
|
|
|
|
// ConnectionDetails_Promise is a wrapper for a ConnectionDetails promised by a client call.
|
|
type ConnectionDetails_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConnectionDetails_Promise) Struct() (ConnectionDetails, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConnectionDetails{s}, err
|
|
}
|
|
|
|
type TunnelAuth struct{ capnp.Struct }
|
|
|
|
// TunnelAuth_TypeID is the unique identifier for the type TunnelAuth.
|
|
const TunnelAuth_TypeID = 0x9496331ab9cd463f
|
|
|
|
func NewTunnelAuth(s *capnp.Segment) (TunnelAuth, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
|
|
return TunnelAuth{st}, err
|
|
}
|
|
|
|
func NewRootTunnelAuth(s *capnp.Segment) (TunnelAuth, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
|
|
return TunnelAuth{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelAuth(msg *capnp.Message) (TunnelAuth, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelAuth{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelAuth) String() string {
|
|
str, _ := text.Marshal(0x9496331ab9cd463f, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelAuth) AccountTag() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s TunnelAuth) HasAccountTag() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelAuth) AccountTagBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s TunnelAuth) SetAccountTag(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s TunnelAuth) TunnelSecret() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s TunnelAuth) HasTunnelSecret() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelAuth) SetTunnelSecret(v []byte) error {
|
|
return s.Struct.SetData(1, v)
|
|
}
|
|
|
|
// TunnelAuth_List is a list of TunnelAuth.
|
|
type TunnelAuth_List struct{ capnp.List }
|
|
|
|
// NewTunnelAuth creates a new list of TunnelAuth.
|
|
func NewTunnelAuth_List(s *capnp.Segment, sz int32) (TunnelAuth_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
|
|
return TunnelAuth_List{l}, err
|
|
}
|
|
|
|
func (s TunnelAuth_List) At(i int) TunnelAuth { return TunnelAuth{s.List.Struct(i)} }
|
|
|
|
func (s TunnelAuth_List) Set(i int, v TunnelAuth) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
func (s TunnelAuth_List) String() string {
|
|
str, _ := text.MarshalList(0x9496331ab9cd463f, s.List)
|
|
return str
|
|
}
|
|
|
|
// TunnelAuth_Promise is a wrapper for a TunnelAuth promised by a client call.
|
|
type TunnelAuth_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelAuth_Promise) Struct() (TunnelAuth, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelAuth{s}, err
|
|
}
|
|
|
|
type RegistrationServer struct{ Client capnp.Client }
|
|
|
|
// RegistrationServer_TypeID is the unique identifier for the type RegistrationServer.
|
|
const RegistrationServer_TypeID = 0xf71695ec7fe85497
|
|
|
|
func (c RegistrationServer) RegisterConnection(ctx context.Context, params func(RegistrationServer_registerConnection_Params) error, opts ...capnp.CallOption) RegistrationServer_registerConnection_Results_Promise {
|
|
if c.Client == nil {
|
|
return RegistrationServer_registerConnection_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "registerConnection",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 3}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(RegistrationServer_registerConnection_Params{Struct: s}) }
|
|
}
|
|
return RegistrationServer_registerConnection_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c RegistrationServer) UnregisterConnection(ctx context.Context, params func(RegistrationServer_unregisterConnection_Params) error, opts ...capnp.CallOption) RegistrationServer_unregisterConnection_Results_Promise {
|
|
if c.Client == nil {
|
|
return RegistrationServer_unregisterConnection_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "unregisterConnection",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(RegistrationServer_unregisterConnection_Params{Struct: s}) }
|
|
}
|
|
return RegistrationServer_unregisterConnection_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c RegistrationServer) UpdateLocalConfiguration(ctx context.Context, params func(RegistrationServer_updateLocalConfiguration_Params) error, opts ...capnp.CallOption) RegistrationServer_updateLocalConfiguration_Results_Promise {
|
|
if c.Client == nil {
|
|
return RegistrationServer_updateLocalConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 2,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "updateLocalConfiguration",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
|
|
call.ParamsFunc = func(s capnp.Struct) error {
|
|
return params(RegistrationServer_updateLocalConfiguration_Params{Struct: s})
|
|
}
|
|
}
|
|
return RegistrationServer_updateLocalConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
|
|
type RegistrationServer_Server interface {
|
|
RegisterConnection(RegistrationServer_registerConnection) error
|
|
|
|
UnregisterConnection(RegistrationServer_unregisterConnection) error
|
|
|
|
UpdateLocalConfiguration(RegistrationServer_updateLocalConfiguration) error
|
|
}
|
|
|
|
func RegistrationServer_ServerToClient(s RegistrationServer_Server) RegistrationServer {
|
|
c, _ := s.(server.Closer)
|
|
return RegistrationServer{Client: server.New(RegistrationServer_Methods(nil, s), c)}
|
|
}
|
|
|
|
func RegistrationServer_Methods(methods []server.Method, s RegistrationServer_Server) []server.Method {
|
|
if cap(methods) == 0 {
|
|
methods = make([]server.Method, 0, 3)
|
|
}
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "registerConnection",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := RegistrationServer_registerConnection{c, opts, RegistrationServer_registerConnection_Params{Struct: p}, RegistrationServer_registerConnection_Results{Struct: r}}
|
|
return s.RegisterConnection(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "unregisterConnection",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := RegistrationServer_unregisterConnection{c, opts, RegistrationServer_unregisterConnection_Params{Struct: p}, RegistrationServer_unregisterConnection_Results{Struct: r}}
|
|
return s.UnregisterConnection(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 2,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "updateLocalConfiguration",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := RegistrationServer_updateLocalConfiguration{c, opts, RegistrationServer_updateLocalConfiguration_Params{Struct: p}, RegistrationServer_updateLocalConfiguration_Results{Struct: r}}
|
|
return s.UpdateLocalConfiguration(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
|
|
})
|
|
|
|
return methods
|
|
}
|
|
|
|
// RegistrationServer_registerConnection holds the arguments for a server call to RegistrationServer.registerConnection.
|
|
type RegistrationServer_registerConnection struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params RegistrationServer_registerConnection_Params
|
|
Results RegistrationServer_registerConnection_Results
|
|
}
|
|
|
|
// RegistrationServer_unregisterConnection holds the arguments for a server call to RegistrationServer.unregisterConnection.
|
|
type RegistrationServer_unregisterConnection struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params RegistrationServer_unregisterConnection_Params
|
|
Results RegistrationServer_unregisterConnection_Results
|
|
}
|
|
|
|
// RegistrationServer_updateLocalConfiguration holds the arguments for a server call to RegistrationServer.updateLocalConfiguration.
|
|
type RegistrationServer_updateLocalConfiguration struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params RegistrationServer_updateLocalConfiguration_Params
|
|
Results RegistrationServer_updateLocalConfiguration_Results
|
|
}
|
|
|
|
type RegistrationServer_registerConnection_Params struct{ capnp.Struct }
|
|
|
|
// RegistrationServer_registerConnection_Params_TypeID is the unique identifier for the type RegistrationServer_registerConnection_Params.
|
|
const RegistrationServer_registerConnection_Params_TypeID = 0xe6646dec8feaa6ee
|
|
|
|
func NewRegistrationServer_registerConnection_Params(s *capnp.Segment) (RegistrationServer_registerConnection_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
|
|
return RegistrationServer_registerConnection_Params{st}, err
|
|
}
|
|
|
|
func NewRootRegistrationServer_registerConnection_Params(s *capnp.Segment) (RegistrationServer_registerConnection_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
|
|
return RegistrationServer_registerConnection_Params{st}, err
|
|
}
|
|
|
|
func ReadRootRegistrationServer_registerConnection_Params(msg *capnp.Message) (RegistrationServer_registerConnection_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return RegistrationServer_registerConnection_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) String() string {
|
|
str, _ := text.Marshal(0xe6646dec8feaa6ee, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) Auth() (TunnelAuth, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return TunnelAuth{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) HasAuth() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) SetAuth(v TunnelAuth) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewAuth sets the auth field to a newly
|
|
// allocated TunnelAuth struct, preferring placement in s's segment.
|
|
func (s RegistrationServer_registerConnection_Params) NewAuth() (TunnelAuth, error) {
|
|
ss, err := NewTunnelAuth(s.Struct.Segment())
|
|
if err != nil {
|
|
return TunnelAuth{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) TunnelId() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) HasTunnelId() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) SetTunnelId(v []byte) error {
|
|
return s.Struct.SetData(1, v)
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) ConnIndex() uint8 {
|
|
return s.Struct.Uint8(0)
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) SetConnIndex(v uint8) {
|
|
s.Struct.SetUint8(0, v)
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) Options() (ConnectionOptions, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return ConnectionOptions{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) HasOptions() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params) SetOptions(v ConnectionOptions) error {
|
|
return s.Struct.SetPtr(2, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewOptions sets the options field to a newly
|
|
// allocated ConnectionOptions struct, preferring placement in s's segment.
|
|
func (s RegistrationServer_registerConnection_Params) NewOptions() (ConnectionOptions, error) {
|
|
ss, err := NewConnectionOptions(s.Struct.Segment())
|
|
if err != nil {
|
|
return ConnectionOptions{}, err
|
|
}
|
|
err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// RegistrationServer_registerConnection_Params_List is a list of RegistrationServer_registerConnection_Params.
|
|
type RegistrationServer_registerConnection_Params_List struct{ capnp.List }
|
|
|
|
// NewRegistrationServer_registerConnection_Params creates a new list of RegistrationServer_registerConnection_Params.
|
|
func NewRegistrationServer_registerConnection_Params_List(s *capnp.Segment, sz int32) (RegistrationServer_registerConnection_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}, sz)
|
|
return RegistrationServer_registerConnection_Params_List{l}, err
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params_List) At(i int) RegistrationServer_registerConnection_Params {
|
|
return RegistrationServer_registerConnection_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params_List) Set(i int, v RegistrationServer_registerConnection_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Params_List) String() string {
|
|
str, _ := text.MarshalList(0xe6646dec8feaa6ee, s.List)
|
|
return str
|
|
}
|
|
|
|
// RegistrationServer_registerConnection_Params_Promise is a wrapper for a RegistrationServer_registerConnection_Params promised by a client call.
|
|
type RegistrationServer_registerConnection_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p RegistrationServer_registerConnection_Params_Promise) Struct() (RegistrationServer_registerConnection_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return RegistrationServer_registerConnection_Params{s}, err
|
|
}
|
|
|
|
func (p RegistrationServer_registerConnection_Params_Promise) Auth() TunnelAuth_Promise {
|
|
return TunnelAuth_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
func (p RegistrationServer_registerConnection_Params_Promise) Options() ConnectionOptions_Promise {
|
|
return ConnectionOptions_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
|
|
}
|
|
|
|
type RegistrationServer_registerConnection_Results struct{ capnp.Struct }
|
|
|
|
// RegistrationServer_registerConnection_Results_TypeID is the unique identifier for the type RegistrationServer_registerConnection_Results.
|
|
const RegistrationServer_registerConnection_Results_TypeID = 0xea50d822450d1f17
|
|
|
|
func NewRegistrationServer_registerConnection_Results(s *capnp.Segment) (RegistrationServer_registerConnection_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return RegistrationServer_registerConnection_Results{st}, err
|
|
}
|
|
|
|
func NewRootRegistrationServer_registerConnection_Results(s *capnp.Segment) (RegistrationServer_registerConnection_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return RegistrationServer_registerConnection_Results{st}, err
|
|
}
|
|
|
|
func ReadRootRegistrationServer_registerConnection_Results(msg *capnp.Message) (RegistrationServer_registerConnection_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return RegistrationServer_registerConnection_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Results) String() string {
|
|
str, _ := text.Marshal(0xea50d822450d1f17, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Results) Result() (ConnectionResponse, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return ConnectionResponse{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Results) HasResult() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Results) SetResult(v ConnectionResponse) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewResult sets the result field to a newly
|
|
// allocated ConnectionResponse struct, preferring placement in s's segment.
|
|
func (s RegistrationServer_registerConnection_Results) NewResult() (ConnectionResponse, error) {
|
|
ss, err := NewConnectionResponse(s.Struct.Segment())
|
|
if err != nil {
|
|
return ConnectionResponse{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// RegistrationServer_registerConnection_Results_List is a list of RegistrationServer_registerConnection_Results.
|
|
type RegistrationServer_registerConnection_Results_List struct{ capnp.List }
|
|
|
|
// NewRegistrationServer_registerConnection_Results creates a new list of RegistrationServer_registerConnection_Results.
|
|
func NewRegistrationServer_registerConnection_Results_List(s *capnp.Segment, sz int32) (RegistrationServer_registerConnection_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return RegistrationServer_registerConnection_Results_List{l}, err
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Results_List) At(i int) RegistrationServer_registerConnection_Results {
|
|
return RegistrationServer_registerConnection_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Results_List) Set(i int, v RegistrationServer_registerConnection_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s RegistrationServer_registerConnection_Results_List) String() string {
|
|
str, _ := text.MarshalList(0xea50d822450d1f17, s.List)
|
|
return str
|
|
}
|
|
|
|
// RegistrationServer_registerConnection_Results_Promise is a wrapper for a RegistrationServer_registerConnection_Results promised by a client call.
|
|
type RegistrationServer_registerConnection_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p RegistrationServer_registerConnection_Results_Promise) Struct() (RegistrationServer_registerConnection_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return RegistrationServer_registerConnection_Results{s}, err
|
|
}
|
|
|
|
func (p RegistrationServer_registerConnection_Results_Promise) Result() ConnectionResponse_Promise {
|
|
return ConnectionResponse_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type RegistrationServer_unregisterConnection_Params struct{ capnp.Struct }
|
|
|
|
// RegistrationServer_unregisterConnection_Params_TypeID is the unique identifier for the type RegistrationServer_unregisterConnection_Params.
|
|
const RegistrationServer_unregisterConnection_Params_TypeID = 0xf9cb7f4431a307d0
|
|
|
|
func NewRegistrationServer_unregisterConnection_Params(s *capnp.Segment) (RegistrationServer_unregisterConnection_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return RegistrationServer_unregisterConnection_Params{st}, err
|
|
}
|
|
|
|
func NewRootRegistrationServer_unregisterConnection_Params(s *capnp.Segment) (RegistrationServer_unregisterConnection_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return RegistrationServer_unregisterConnection_Params{st}, err
|
|
}
|
|
|
|
func ReadRootRegistrationServer_unregisterConnection_Params(msg *capnp.Message) (RegistrationServer_unregisterConnection_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return RegistrationServer_unregisterConnection_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s RegistrationServer_unregisterConnection_Params) String() string {
|
|
str, _ := text.Marshal(0xf9cb7f4431a307d0, s.Struct)
|
|
return str
|
|
}
|
|
|
|
// RegistrationServer_unregisterConnection_Params_List is a list of RegistrationServer_unregisterConnection_Params.
|
|
type RegistrationServer_unregisterConnection_Params_List struct{ capnp.List }
|
|
|
|
// NewRegistrationServer_unregisterConnection_Params creates a new list of RegistrationServer_unregisterConnection_Params.
|
|
func NewRegistrationServer_unregisterConnection_Params_List(s *capnp.Segment, sz int32) (RegistrationServer_unregisterConnection_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
|
|
return RegistrationServer_unregisterConnection_Params_List{l}, err
|
|
}
|
|
|
|
func (s RegistrationServer_unregisterConnection_Params_List) At(i int) RegistrationServer_unregisterConnection_Params {
|
|
return RegistrationServer_unregisterConnection_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s RegistrationServer_unregisterConnection_Params_List) Set(i int, v RegistrationServer_unregisterConnection_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s RegistrationServer_unregisterConnection_Params_List) String() string {
|
|
str, _ := text.MarshalList(0xf9cb7f4431a307d0, s.List)
|
|
return str
|
|
}
|
|
|
|
// RegistrationServer_unregisterConnection_Params_Promise is a wrapper for a RegistrationServer_unregisterConnection_Params promised by a client call.
|
|
type RegistrationServer_unregisterConnection_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p RegistrationServer_unregisterConnection_Params_Promise) Struct() (RegistrationServer_unregisterConnection_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return RegistrationServer_unregisterConnection_Params{s}, err
|
|
}
|
|
|
|
type RegistrationServer_unregisterConnection_Results struct{ capnp.Struct }
|
|
|
|
// RegistrationServer_unregisterConnection_Results_TypeID is the unique identifier for the type RegistrationServer_unregisterConnection_Results.
|
|
const RegistrationServer_unregisterConnection_Results_TypeID = 0xb046e578094b1ead
|
|
|
|
func NewRegistrationServer_unregisterConnection_Results(s *capnp.Segment) (RegistrationServer_unregisterConnection_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return RegistrationServer_unregisterConnection_Results{st}, err
|
|
}
|
|
|
|
func NewRootRegistrationServer_unregisterConnection_Results(s *capnp.Segment) (RegistrationServer_unregisterConnection_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return RegistrationServer_unregisterConnection_Results{st}, err
|
|
}
|
|
|
|
func ReadRootRegistrationServer_unregisterConnection_Results(msg *capnp.Message) (RegistrationServer_unregisterConnection_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return RegistrationServer_unregisterConnection_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s RegistrationServer_unregisterConnection_Results) String() string {
|
|
str, _ := text.Marshal(0xb046e578094b1ead, s.Struct)
|
|
return str
|
|
}
|
|
|
|
// RegistrationServer_unregisterConnection_Results_List is a list of RegistrationServer_unregisterConnection_Results.
|
|
type RegistrationServer_unregisterConnection_Results_List struct{ capnp.List }
|
|
|
|
// NewRegistrationServer_unregisterConnection_Results creates a new list of RegistrationServer_unregisterConnection_Results.
|
|
func NewRegistrationServer_unregisterConnection_Results_List(s *capnp.Segment, sz int32) (RegistrationServer_unregisterConnection_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
|
|
return RegistrationServer_unregisterConnection_Results_List{l}, err
|
|
}
|
|
|
|
func (s RegistrationServer_unregisterConnection_Results_List) At(i int) RegistrationServer_unregisterConnection_Results {
|
|
return RegistrationServer_unregisterConnection_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s RegistrationServer_unregisterConnection_Results_List) Set(i int, v RegistrationServer_unregisterConnection_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s RegistrationServer_unregisterConnection_Results_List) String() string {
|
|
str, _ := text.MarshalList(0xb046e578094b1ead, s.List)
|
|
return str
|
|
}
|
|
|
|
// RegistrationServer_unregisterConnection_Results_Promise is a wrapper for a RegistrationServer_unregisterConnection_Results promised by a client call.
|
|
type RegistrationServer_unregisterConnection_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p RegistrationServer_unregisterConnection_Results_Promise) Struct() (RegistrationServer_unregisterConnection_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return RegistrationServer_unregisterConnection_Results{s}, err
|
|
}
|
|
|
|
type RegistrationServer_updateLocalConfiguration_Params struct{ capnp.Struct }
|
|
|
|
// RegistrationServer_updateLocalConfiguration_Params_TypeID is the unique identifier for the type RegistrationServer_updateLocalConfiguration_Params.
|
|
const RegistrationServer_updateLocalConfiguration_Params_TypeID = 0xc5d6e311876a3604
|
|
|
|
func NewRegistrationServer_updateLocalConfiguration_Params(s *capnp.Segment) (RegistrationServer_updateLocalConfiguration_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return RegistrationServer_updateLocalConfiguration_Params{st}, err
|
|
}
|
|
|
|
func NewRootRegistrationServer_updateLocalConfiguration_Params(s *capnp.Segment) (RegistrationServer_updateLocalConfiguration_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return RegistrationServer_updateLocalConfiguration_Params{st}, err
|
|
}
|
|
|
|
func ReadRootRegistrationServer_updateLocalConfiguration_Params(msg *capnp.Message) (RegistrationServer_updateLocalConfiguration_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return RegistrationServer_updateLocalConfiguration_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s RegistrationServer_updateLocalConfiguration_Params) String() string {
|
|
str, _ := text.Marshal(0xc5d6e311876a3604, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s RegistrationServer_updateLocalConfiguration_Params) Config() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s RegistrationServer_updateLocalConfiguration_Params) HasConfig() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationServer_updateLocalConfiguration_Params) SetConfig(v []byte) error {
|
|
return s.Struct.SetData(0, v)
|
|
}
|
|
|
|
// RegistrationServer_updateLocalConfiguration_Params_List is a list of RegistrationServer_updateLocalConfiguration_Params.
|
|
type RegistrationServer_updateLocalConfiguration_Params_List struct{ capnp.List }
|
|
|
|
// NewRegistrationServer_updateLocalConfiguration_Params creates a new list of RegistrationServer_updateLocalConfiguration_Params.
|
|
func NewRegistrationServer_updateLocalConfiguration_Params_List(s *capnp.Segment, sz int32) (RegistrationServer_updateLocalConfiguration_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return RegistrationServer_updateLocalConfiguration_Params_List{l}, err
|
|
}
|
|
|
|
func (s RegistrationServer_updateLocalConfiguration_Params_List) At(i int) RegistrationServer_updateLocalConfiguration_Params {
|
|
return RegistrationServer_updateLocalConfiguration_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s RegistrationServer_updateLocalConfiguration_Params_List) Set(i int, v RegistrationServer_updateLocalConfiguration_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s RegistrationServer_updateLocalConfiguration_Params_List) String() string {
|
|
str, _ := text.MarshalList(0xc5d6e311876a3604, s.List)
|
|
return str
|
|
}
|
|
|
|
// RegistrationServer_updateLocalConfiguration_Params_Promise is a wrapper for a RegistrationServer_updateLocalConfiguration_Params promised by a client call.
|
|
type RegistrationServer_updateLocalConfiguration_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p RegistrationServer_updateLocalConfiguration_Params_Promise) Struct() (RegistrationServer_updateLocalConfiguration_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return RegistrationServer_updateLocalConfiguration_Params{s}, err
|
|
}
|
|
|
|
type RegistrationServer_updateLocalConfiguration_Results struct{ capnp.Struct }
|
|
|
|
// RegistrationServer_updateLocalConfiguration_Results_TypeID is the unique identifier for the type RegistrationServer_updateLocalConfiguration_Results.
|
|
const RegistrationServer_updateLocalConfiguration_Results_TypeID = 0xe5ceae5d6897d7be
|
|
|
|
func NewRegistrationServer_updateLocalConfiguration_Results(s *capnp.Segment) (RegistrationServer_updateLocalConfiguration_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return RegistrationServer_updateLocalConfiguration_Results{st}, err
|
|
}
|
|
|
|
func NewRootRegistrationServer_updateLocalConfiguration_Results(s *capnp.Segment) (RegistrationServer_updateLocalConfiguration_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return RegistrationServer_updateLocalConfiguration_Results{st}, err
|
|
}
|
|
|
|
func ReadRootRegistrationServer_updateLocalConfiguration_Results(msg *capnp.Message) (RegistrationServer_updateLocalConfiguration_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return RegistrationServer_updateLocalConfiguration_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s RegistrationServer_updateLocalConfiguration_Results) String() string {
|
|
str, _ := text.Marshal(0xe5ceae5d6897d7be, s.Struct)
|
|
return str
|
|
}
|
|
|
|
// RegistrationServer_updateLocalConfiguration_Results_List is a list of RegistrationServer_updateLocalConfiguration_Results.
|
|
type RegistrationServer_updateLocalConfiguration_Results_List struct{ capnp.List }
|
|
|
|
// NewRegistrationServer_updateLocalConfiguration_Results creates a new list of RegistrationServer_updateLocalConfiguration_Results.
|
|
func NewRegistrationServer_updateLocalConfiguration_Results_List(s *capnp.Segment, sz int32) (RegistrationServer_updateLocalConfiguration_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
|
|
return RegistrationServer_updateLocalConfiguration_Results_List{l}, err
|
|
}
|
|
|
|
func (s RegistrationServer_updateLocalConfiguration_Results_List) At(i int) RegistrationServer_updateLocalConfiguration_Results {
|
|
return RegistrationServer_updateLocalConfiguration_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s RegistrationServer_updateLocalConfiguration_Results_List) Set(i int, v RegistrationServer_updateLocalConfiguration_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s RegistrationServer_updateLocalConfiguration_Results_List) String() string {
|
|
str, _ := text.MarshalList(0xe5ceae5d6897d7be, s.List)
|
|
return str
|
|
}
|
|
|
|
// RegistrationServer_updateLocalConfiguration_Results_Promise is a wrapper for a RegistrationServer_updateLocalConfiguration_Results promised by a client call.
|
|
type RegistrationServer_updateLocalConfiguration_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p RegistrationServer_updateLocalConfiguration_Results_Promise) Struct() (RegistrationServer_updateLocalConfiguration_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return RegistrationServer_updateLocalConfiguration_Results{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/proto/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/proto/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/proto/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) ObsoleteDeclarativeTunnelConnect(ctx context.Context, params func(TunnelServer_obsoleteDeclarativeTunnelConnect_Params) error, opts ...capnp.CallOption) TunnelServer_obsoleteDeclarativeTunnelConnect_Results_Promise {
|
|
if c.Client == nil {
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 3,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "obsoleteDeclarativeTunnelConnect",
|
|
},
|
|
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_obsoleteDeclarativeTunnelConnect_Params{Struct: s})
|
|
}
|
|
}
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) Authenticate(ctx context.Context, params func(TunnelServer_authenticate_Params) error, opts ...capnp.CallOption) TunnelServer_authenticate_Results_Promise {
|
|
if c.Client == nil {
|
|
return TunnelServer_authenticate_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 4,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "authenticate",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 3}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_authenticate_Params{Struct: s}) }
|
|
}
|
|
return TunnelServer_authenticate_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) ReconnectTunnel(ctx context.Context, params func(TunnelServer_reconnectTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_reconnectTunnel_Results_Promise {
|
|
if c.Client == nil {
|
|
return TunnelServer_reconnectTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 5,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "reconnectTunnel",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 5}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_reconnectTunnel_Params{Struct: s}) }
|
|
}
|
|
return TunnelServer_reconnectTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) RegisterConnection(ctx context.Context, params func(RegistrationServer_registerConnection_Params) error, opts ...capnp.CallOption) RegistrationServer_registerConnection_Results_Promise {
|
|
if c.Client == nil {
|
|
return RegistrationServer_registerConnection_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "registerConnection",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 3}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(RegistrationServer_registerConnection_Params{Struct: s}) }
|
|
}
|
|
return RegistrationServer_registerConnection_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) UnregisterConnection(ctx context.Context, params func(RegistrationServer_unregisterConnection_Params) error, opts ...capnp.CallOption) RegistrationServer_unregisterConnection_Results_Promise {
|
|
if c.Client == nil {
|
|
return RegistrationServer_unregisterConnection_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "unregisterConnection",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(RegistrationServer_unregisterConnection_Params{Struct: s}) }
|
|
}
|
|
return RegistrationServer_unregisterConnection_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) UpdateLocalConfiguration(ctx context.Context, params func(RegistrationServer_updateLocalConfiguration_Params) error, opts ...capnp.CallOption) RegistrationServer_updateLocalConfiguration_Results_Promise {
|
|
if c.Client == nil {
|
|
return RegistrationServer_updateLocalConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 2,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "updateLocalConfiguration",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
|
|
call.ParamsFunc = func(s capnp.Struct) error {
|
|
return params(RegistrationServer_updateLocalConfiguration_Params{Struct: s})
|
|
}
|
|
}
|
|
return RegistrationServer_updateLocalConfiguration_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
|
|
|
|
ObsoleteDeclarativeTunnelConnect(TunnelServer_obsoleteDeclarativeTunnelConnect) error
|
|
|
|
Authenticate(TunnelServer_authenticate) error
|
|
|
|
ReconnectTunnel(TunnelServer_reconnectTunnel) error
|
|
|
|
RegisterConnection(RegistrationServer_registerConnection) error
|
|
|
|
UnregisterConnection(RegistrationServer_unregisterConnection) error
|
|
|
|
UpdateLocalConfiguration(RegistrationServer_updateLocalConfiguration) 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, 9)
|
|
}
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/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/proto/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/proto/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/proto/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "obsoleteDeclarativeTunnelConnect",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_obsoleteDeclarativeTunnelConnect{c, opts, TunnelServer_obsoleteDeclarativeTunnelConnect_Params{Struct: p}, TunnelServer_obsoleteDeclarativeTunnelConnect_Results{Struct: r}}
|
|
return s.ObsoleteDeclarativeTunnelConnect(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 4,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "authenticate",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_authenticate{c, opts, TunnelServer_authenticate_Params{Struct: p}, TunnelServer_authenticate_Results{Struct: r}}
|
|
return s.Authenticate(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 5,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "reconnectTunnel",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_reconnectTunnel{c, opts, TunnelServer_reconnectTunnel_Params{Struct: p}, TunnelServer_reconnectTunnel_Results{Struct: r}}
|
|
return s.ReconnectTunnel(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "registerConnection",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := RegistrationServer_registerConnection{c, opts, RegistrationServer_registerConnection_Params{Struct: p}, RegistrationServer_registerConnection_Results{Struct: r}}
|
|
return s.RegisterConnection(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "unregisterConnection",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := RegistrationServer_unregisterConnection{c, opts, RegistrationServer_unregisterConnection_Params{Struct: p}, RegistrationServer_unregisterConnection_Results{Struct: r}}
|
|
return s.UnregisterConnection(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 2,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:RegistrationServer",
|
|
MethodName: "updateLocalConfiguration",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := RegistrationServer_updateLocalConfiguration{c, opts, RegistrationServer_updateLocalConfiguration_Params{Struct: p}, RegistrationServer_updateLocalConfiguration_Results{Struct: r}}
|
|
return s.UpdateLocalConfiguration(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
|
|
})
|
|
|
|
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_obsoleteDeclarativeTunnelConnect holds the arguments for a server call to TunnelServer.obsoleteDeclarativeTunnelConnect.
|
|
type TunnelServer_obsoleteDeclarativeTunnelConnect struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params TunnelServer_obsoleteDeclarativeTunnelConnect_Params
|
|
Results TunnelServer_obsoleteDeclarativeTunnelConnect_Results
|
|
}
|
|
|
|
// TunnelServer_authenticate holds the arguments for a server call to TunnelServer.authenticate.
|
|
type TunnelServer_authenticate struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params TunnelServer_authenticate_Params
|
|
Results TunnelServer_authenticate_Results
|
|
}
|
|
|
|
// TunnelServer_reconnectTunnel holds the arguments for a server call to TunnelServer.reconnectTunnel.
|
|
type TunnelServer_reconnectTunnel struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params TunnelServer_reconnectTunnel_Params
|
|
Results TunnelServer_reconnectTunnel_Results
|
|
}
|
|
|
|
type TunnelServer_registerTunnel_Params struct{ capnp.Struct }
|
|
|
|
// TunnelServer_registerTunnel_Params_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Params.
|
|
const TunnelServer_registerTunnel_Params_TypeID = 0xb70431c0dc014915
|
|
|
|
func NewTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return TunnelServer_registerTunnel_Params{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return TunnelServer_registerTunnel_Params{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_registerTunnel_Params(msg *capnp.Message) (TunnelServer_registerTunnel_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_registerTunnel_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) String() string {
|
|
str, _ := text.Marshal(0xb70431c0dc014915, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) OriginCert() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) HasOriginCert() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) SetOriginCert(v []byte) error {
|
|
return s.Struct.SetData(0, v)
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) Hostname() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) HasHostname() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) HostnameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) SetHostname(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) Options() (RegistrationOptions, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return RegistrationOptions{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) HasOptions() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) SetOptions(v RegistrationOptions) error {
|
|
return s.Struct.SetPtr(2, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewOptions sets the options field to a newly
|
|
// allocated RegistrationOptions struct, preferring placement in s's segment.
|
|
func (s TunnelServer_registerTunnel_Params) NewOptions() (RegistrationOptions, error) {
|
|
ss, err := NewRegistrationOptions(s.Struct.Segment())
|
|
if err != nil {
|
|
return RegistrationOptions{}, err
|
|
}
|
|
err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_registerTunnel_Params_List is a list of TunnelServer_registerTunnel_Params.
|
|
type TunnelServer_registerTunnel_Params_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_registerTunnel_Params creates a new list of TunnelServer_registerTunnel_Params.
|
|
func NewTunnelServer_registerTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
|
|
return TunnelServer_registerTunnel_Params_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params_List) At(i int) TunnelServer_registerTunnel_Params {
|
|
return TunnelServer_registerTunnel_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params_List) Set(i int, v TunnelServer_registerTunnel_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
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_obsoleteDeclarativeTunnelConnect_Params struct{ capnp.Struct }
|
|
|
|
// TunnelServer_obsoleteDeclarativeTunnelConnect_Params_TypeID is the unique identifier for the type TunnelServer_obsoleteDeclarativeTunnelConnect_Params.
|
|
const TunnelServer_obsoleteDeclarativeTunnelConnect_Params_TypeID = 0xa766b24d4fe5da35
|
|
|
|
func NewTunnelServer_obsoleteDeclarativeTunnelConnect_Params(s *capnp.Segment) (TunnelServer_obsoleteDeclarativeTunnelConnect_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Params{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_obsoleteDeclarativeTunnelConnect_Params(s *capnp.Segment) (TunnelServer_obsoleteDeclarativeTunnelConnect_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Params{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_obsoleteDeclarativeTunnelConnect_Params(msg *capnp.Message) (TunnelServer_obsoleteDeclarativeTunnelConnect_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Params) String() string {
|
|
str, _ := text.Marshal(0xa766b24d4fe5da35, s.Struct)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List is a list of TunnelServer_obsoleteDeclarativeTunnelConnect_Params.
|
|
type TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_obsoleteDeclarativeTunnelConnect_Params creates a new list of TunnelServer_obsoleteDeclarativeTunnelConnect_Params.
|
|
func NewTunnelServer_obsoleteDeclarativeTunnelConnect_Params_List(s *capnp.Segment, sz int32) (TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List) At(i int) TunnelServer_obsoleteDeclarativeTunnelConnect_Params {
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List) Set(i int, v TunnelServer_obsoleteDeclarativeTunnelConnect_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List) String() string {
|
|
str, _ := text.MarshalList(0xa766b24d4fe5da35, s.List)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_obsoleteDeclarativeTunnelConnect_Params_Promise is a wrapper for a TunnelServer_obsoleteDeclarativeTunnelConnect_Params promised by a client call.
|
|
type TunnelServer_obsoleteDeclarativeTunnelConnect_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_obsoleteDeclarativeTunnelConnect_Params_Promise) Struct() (TunnelServer_obsoleteDeclarativeTunnelConnect_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Params{s}, err
|
|
}
|
|
|
|
type TunnelServer_obsoleteDeclarativeTunnelConnect_Results struct{ capnp.Struct }
|
|
|
|
// TunnelServer_obsoleteDeclarativeTunnelConnect_Results_TypeID is the unique identifier for the type TunnelServer_obsoleteDeclarativeTunnelConnect_Results.
|
|
const TunnelServer_obsoleteDeclarativeTunnelConnect_Results_TypeID = 0xfeac5c8f4899ef7c
|
|
|
|
func NewTunnelServer_obsoleteDeclarativeTunnelConnect_Results(s *capnp.Segment) (TunnelServer_obsoleteDeclarativeTunnelConnect_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_obsoleteDeclarativeTunnelConnect_Results(s *capnp.Segment) (TunnelServer_obsoleteDeclarativeTunnelConnect_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_obsoleteDeclarativeTunnelConnect_Results(msg *capnp.Message) (TunnelServer_obsoleteDeclarativeTunnelConnect_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Results) String() string {
|
|
str, _ := text.Marshal(0xfeac5c8f4899ef7c, s.Struct)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List is a list of TunnelServer_obsoleteDeclarativeTunnelConnect_Results.
|
|
type TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_obsoleteDeclarativeTunnelConnect_Results creates a new list of TunnelServer_obsoleteDeclarativeTunnelConnect_Results.
|
|
func NewTunnelServer_obsoleteDeclarativeTunnelConnect_Results_List(s *capnp.Segment, sz int32) (TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List) At(i int) TunnelServer_obsoleteDeclarativeTunnelConnect_Results {
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List) Set(i int, v TunnelServer_obsoleteDeclarativeTunnelConnect_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List) String() string {
|
|
str, _ := text.MarshalList(0xfeac5c8f4899ef7c, s.List)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_obsoleteDeclarativeTunnelConnect_Results_Promise is a wrapper for a TunnelServer_obsoleteDeclarativeTunnelConnect_Results promised by a client call.
|
|
type TunnelServer_obsoleteDeclarativeTunnelConnect_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_obsoleteDeclarativeTunnelConnect_Results_Promise) Struct() (TunnelServer_obsoleteDeclarativeTunnelConnect_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results{s}, err
|
|
}
|
|
|
|
type TunnelServer_authenticate_Params struct{ capnp.Struct }
|
|
|
|
// TunnelServer_authenticate_Params_TypeID is the unique identifier for the type TunnelServer_authenticate_Params.
|
|
const TunnelServer_authenticate_Params_TypeID = 0x85c8cea1ab1894f3
|
|
|
|
func NewTunnelServer_authenticate_Params(s *capnp.Segment) (TunnelServer_authenticate_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return TunnelServer_authenticate_Params{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_authenticate_Params(s *capnp.Segment) (TunnelServer_authenticate_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return TunnelServer_authenticate_Params{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_authenticate_Params(msg *capnp.Message) (TunnelServer_authenticate_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_authenticate_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params) String() string {
|
|
str, _ := text.Marshal(0x85c8cea1ab1894f3, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params) OriginCert() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params) HasOriginCert() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params) SetOriginCert(v []byte) error {
|
|
return s.Struct.SetData(0, v)
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params) Hostname() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params) HasHostname() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params) HostnameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params) SetHostname(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params) Options() (RegistrationOptions, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return RegistrationOptions{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params) HasOptions() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params) SetOptions(v RegistrationOptions) error {
|
|
return s.Struct.SetPtr(2, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewOptions sets the options field to a newly
|
|
// allocated RegistrationOptions struct, preferring placement in s's segment.
|
|
func (s TunnelServer_authenticate_Params) NewOptions() (RegistrationOptions, error) {
|
|
ss, err := NewRegistrationOptions(s.Struct.Segment())
|
|
if err != nil {
|
|
return RegistrationOptions{}, err
|
|
}
|
|
err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_authenticate_Params_List is a list of TunnelServer_authenticate_Params.
|
|
type TunnelServer_authenticate_Params_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_authenticate_Params creates a new list of TunnelServer_authenticate_Params.
|
|
func NewTunnelServer_authenticate_Params_List(s *capnp.Segment, sz int32) (TunnelServer_authenticate_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
|
|
return TunnelServer_authenticate_Params_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params_List) At(i int) TunnelServer_authenticate_Params {
|
|
return TunnelServer_authenticate_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params_List) Set(i int, v TunnelServer_authenticate_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Params_List) String() string {
|
|
str, _ := text.MarshalList(0x85c8cea1ab1894f3, s.List)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_authenticate_Params_Promise is a wrapper for a TunnelServer_authenticate_Params promised by a client call.
|
|
type TunnelServer_authenticate_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_authenticate_Params_Promise) Struct() (TunnelServer_authenticate_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_authenticate_Params{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_authenticate_Params_Promise) Options() RegistrationOptions_Promise {
|
|
return RegistrationOptions_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
|
|
}
|
|
|
|
type TunnelServer_authenticate_Results struct{ capnp.Struct }
|
|
|
|
// TunnelServer_authenticate_Results_TypeID is the unique identifier for the type TunnelServer_authenticate_Results.
|
|
const TunnelServer_authenticate_Results_TypeID = 0xfc5edf80e39c0796
|
|
|
|
func NewTunnelServer_authenticate_Results(s *capnp.Segment) (TunnelServer_authenticate_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_authenticate_Results{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_authenticate_Results(s *capnp.Segment) (TunnelServer_authenticate_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_authenticate_Results{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_authenticate_Results(msg *capnp.Message) (TunnelServer_authenticate_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_authenticate_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Results) String() string {
|
|
str, _ := text.Marshal(0xfc5edf80e39c0796, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Results) Result() (AuthenticateResponse, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return AuthenticateResponse{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Results) HasResult() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Results) SetResult(v AuthenticateResponse) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewResult sets the result field to a newly
|
|
// allocated AuthenticateResponse struct, preferring placement in s's segment.
|
|
func (s TunnelServer_authenticate_Results) NewResult() (AuthenticateResponse, error) {
|
|
ss, err := NewAuthenticateResponse(s.Struct.Segment())
|
|
if err != nil {
|
|
return AuthenticateResponse{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_authenticate_Results_List is a list of TunnelServer_authenticate_Results.
|
|
type TunnelServer_authenticate_Results_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_authenticate_Results creates a new list of TunnelServer_authenticate_Results.
|
|
func NewTunnelServer_authenticate_Results_List(s *capnp.Segment, sz int32) (TunnelServer_authenticate_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return TunnelServer_authenticate_Results_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Results_List) At(i int) TunnelServer_authenticate_Results {
|
|
return TunnelServer_authenticate_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Results_List) Set(i int, v TunnelServer_authenticate_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s TunnelServer_authenticate_Results_List) String() string {
|
|
str, _ := text.MarshalList(0xfc5edf80e39c0796, s.List)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_authenticate_Results_Promise is a wrapper for a TunnelServer_authenticate_Results promised by a client call.
|
|
type TunnelServer_authenticate_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_authenticate_Results_Promise) Struct() (TunnelServer_authenticate_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_authenticate_Results{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_authenticate_Results_Promise) Result() AuthenticateResponse_Promise {
|
|
return AuthenticateResponse_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type TunnelServer_reconnectTunnel_Params struct{ capnp.Struct }
|
|
|
|
// TunnelServer_reconnectTunnel_Params_TypeID is the unique identifier for the type TunnelServer_reconnectTunnel_Params.
|
|
const TunnelServer_reconnectTunnel_Params_TypeID = 0xa353a3556df74984
|
|
|
|
func NewTunnelServer_reconnectTunnel_Params(s *capnp.Segment) (TunnelServer_reconnectTunnel_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 5})
|
|
return TunnelServer_reconnectTunnel_Params{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_reconnectTunnel_Params(s *capnp.Segment) (TunnelServer_reconnectTunnel_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 5})
|
|
return TunnelServer_reconnectTunnel_Params{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_reconnectTunnel_Params(msg *capnp.Message) (TunnelServer_reconnectTunnel_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_reconnectTunnel_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) String() string {
|
|
str, _ := text.Marshal(0xa353a3556df74984, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) Jwt() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) HasJwt() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) SetJwt(v []byte) error {
|
|
return s.Struct.SetData(0, v)
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) EventDigest() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) HasEventDigest() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) SetEventDigest(v []byte) error {
|
|
return s.Struct.SetData(1, v)
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) ConnDigest() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) HasConnDigest() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) SetConnDigest(v []byte) error {
|
|
return s.Struct.SetData(2, v)
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) Hostname() (string, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) HasHostname() bool {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) HostnameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) SetHostname(v string) error {
|
|
return s.Struct.SetText(3, v)
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) Options() (RegistrationOptions, error) {
|
|
p, err := s.Struct.Ptr(4)
|
|
return RegistrationOptions{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) HasOptions() bool {
|
|
p, err := s.Struct.Ptr(4)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params) SetOptions(v RegistrationOptions) error {
|
|
return s.Struct.SetPtr(4, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewOptions sets the options field to a newly
|
|
// allocated RegistrationOptions struct, preferring placement in s's segment.
|
|
func (s TunnelServer_reconnectTunnel_Params) NewOptions() (RegistrationOptions, error) {
|
|
ss, err := NewRegistrationOptions(s.Struct.Segment())
|
|
if err != nil {
|
|
return RegistrationOptions{}, err
|
|
}
|
|
err = s.Struct.SetPtr(4, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_reconnectTunnel_Params_List is a list of TunnelServer_reconnectTunnel_Params.
|
|
type TunnelServer_reconnectTunnel_Params_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_reconnectTunnel_Params creates a new list of TunnelServer_reconnectTunnel_Params.
|
|
func NewTunnelServer_reconnectTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_reconnectTunnel_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 5}, sz)
|
|
return TunnelServer_reconnectTunnel_Params_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params_List) At(i int) TunnelServer_reconnectTunnel_Params {
|
|
return TunnelServer_reconnectTunnel_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params_List) Set(i int, v TunnelServer_reconnectTunnel_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Params_List) String() string {
|
|
str, _ := text.MarshalList(0xa353a3556df74984, s.List)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_reconnectTunnel_Params_Promise is a wrapper for a TunnelServer_reconnectTunnel_Params promised by a client call.
|
|
type TunnelServer_reconnectTunnel_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_reconnectTunnel_Params_Promise) Struct() (TunnelServer_reconnectTunnel_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_reconnectTunnel_Params{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_reconnectTunnel_Params_Promise) Options() RegistrationOptions_Promise {
|
|
return RegistrationOptions_Promise{Pipeline: p.Pipeline.GetPipeline(4)}
|
|
}
|
|
|
|
type TunnelServer_reconnectTunnel_Results struct{ capnp.Struct }
|
|
|
|
// TunnelServer_reconnectTunnel_Results_TypeID is the unique identifier for the type TunnelServer_reconnectTunnel_Results.
|
|
const TunnelServer_reconnectTunnel_Results_TypeID = 0xd4d18de97bb12de3
|
|
|
|
func NewTunnelServer_reconnectTunnel_Results(s *capnp.Segment) (TunnelServer_reconnectTunnel_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_reconnectTunnel_Results{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_reconnectTunnel_Results(s *capnp.Segment) (TunnelServer_reconnectTunnel_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_reconnectTunnel_Results{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_reconnectTunnel_Results(msg *capnp.Message) (TunnelServer_reconnectTunnel_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_reconnectTunnel_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Results) String() string {
|
|
str, _ := text.Marshal(0xd4d18de97bb12de3, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Results) Result() (TunnelRegistration, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return TunnelRegistration{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Results) HasResult() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Results) SetResult(v TunnelRegistration) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewResult sets the result field to a newly
|
|
// allocated TunnelRegistration struct, preferring placement in s's segment.
|
|
func (s TunnelServer_reconnectTunnel_Results) NewResult() (TunnelRegistration, error) {
|
|
ss, err := NewTunnelRegistration(s.Struct.Segment())
|
|
if err != nil {
|
|
return TunnelRegistration{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_reconnectTunnel_Results_List is a list of TunnelServer_reconnectTunnel_Results.
|
|
type TunnelServer_reconnectTunnel_Results_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_reconnectTunnel_Results creates a new list of TunnelServer_reconnectTunnel_Results.
|
|
func NewTunnelServer_reconnectTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_reconnectTunnel_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return TunnelServer_reconnectTunnel_Results_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Results_List) At(i int) TunnelServer_reconnectTunnel_Results {
|
|
return TunnelServer_reconnectTunnel_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Results_List) Set(i int, v TunnelServer_reconnectTunnel_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s TunnelServer_reconnectTunnel_Results_List) String() string {
|
|
str, _ := text.MarshalList(0xd4d18de97bb12de3, s.List)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_reconnectTunnel_Results_Promise is a wrapper for a TunnelServer_reconnectTunnel_Results promised by a client call.
|
|
type TunnelServer_reconnectTunnel_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_reconnectTunnel_Results_Promise) Struct() (TunnelServer_reconnectTunnel_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_reconnectTunnel_Results{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_reconnectTunnel_Results_Promise) Result() TunnelRegistration_Promise {
|
|
return TunnelRegistration_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type RegisterUdpSessionResponse struct{ capnp.Struct }
|
|
|
|
// RegisterUdpSessionResponse_TypeID is the unique identifier for the type RegisterUdpSessionResponse.
|
|
const RegisterUdpSessionResponse_TypeID = 0xab6d5210c1f26687
|
|
|
|
func NewRegisterUdpSessionResponse(s *capnp.Segment) (RegisterUdpSessionResponse, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
|
|
return RegisterUdpSessionResponse{st}, err
|
|
}
|
|
|
|
func NewRootRegisterUdpSessionResponse(s *capnp.Segment) (RegisterUdpSessionResponse, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
|
|
return RegisterUdpSessionResponse{st}, err
|
|
}
|
|
|
|
func ReadRootRegisterUdpSessionResponse(msg *capnp.Message) (RegisterUdpSessionResponse, error) {
|
|
root, err := msg.RootPtr()
|
|
return RegisterUdpSessionResponse{root.Struct()}, err
|
|
}
|
|
|
|
func (s RegisterUdpSessionResponse) String() string {
|
|
str, _ := text.Marshal(0xab6d5210c1f26687, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s RegisterUdpSessionResponse) Err() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegisterUdpSessionResponse) HasErr() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegisterUdpSessionResponse) ErrBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegisterUdpSessionResponse) SetErr(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s RegisterUdpSessionResponse) Spans() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s RegisterUdpSessionResponse) HasSpans() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegisterUdpSessionResponse) SetSpans(v []byte) error {
|
|
return s.Struct.SetData(1, v)
|
|
}
|
|
|
|
// RegisterUdpSessionResponse_List is a list of RegisterUdpSessionResponse.
|
|
type RegisterUdpSessionResponse_List struct{ capnp.List }
|
|
|
|
// NewRegisterUdpSessionResponse creates a new list of RegisterUdpSessionResponse.
|
|
func NewRegisterUdpSessionResponse_List(s *capnp.Segment, sz int32) (RegisterUdpSessionResponse_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
|
|
return RegisterUdpSessionResponse_List{l}, err
|
|
}
|
|
|
|
func (s RegisterUdpSessionResponse_List) At(i int) RegisterUdpSessionResponse {
|
|
return RegisterUdpSessionResponse{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s RegisterUdpSessionResponse_List) Set(i int, v RegisterUdpSessionResponse) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s RegisterUdpSessionResponse_List) String() string {
|
|
str, _ := text.MarshalList(0xab6d5210c1f26687, s.List)
|
|
return str
|
|
}
|
|
|
|
// RegisterUdpSessionResponse_Promise is a wrapper for a RegisterUdpSessionResponse promised by a client call.
|
|
type RegisterUdpSessionResponse_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p RegisterUdpSessionResponse_Promise) Struct() (RegisterUdpSessionResponse, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return RegisterUdpSessionResponse{s}, err
|
|
}
|
|
|
|
type SessionManager struct{ Client capnp.Client }
|
|
|
|
// SessionManager_TypeID is the unique identifier for the type SessionManager.
|
|
const SessionManager_TypeID = 0x839445a59fb01686
|
|
|
|
func (c SessionManager) RegisterUdpSession(ctx context.Context, params func(SessionManager_registerUdpSession_Params) error, opts ...capnp.CallOption) SessionManager_registerUdpSession_Results_Promise {
|
|
if c.Client == nil {
|
|
return SessionManager_registerUdpSession_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0x839445a59fb01686,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:SessionManager",
|
|
MethodName: "registerUdpSession",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 16, PointerCount: 3}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(SessionManager_registerUdpSession_Params{Struct: s}) }
|
|
}
|
|
return SessionManager_registerUdpSession_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c SessionManager) UnregisterUdpSession(ctx context.Context, params func(SessionManager_unregisterUdpSession_Params) error, opts ...capnp.CallOption) SessionManager_unregisterUdpSession_Results_Promise {
|
|
if c.Client == nil {
|
|
return SessionManager_unregisterUdpSession_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0x839445a59fb01686,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:SessionManager",
|
|
MethodName: "unregisterUdpSession",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 2}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(SessionManager_unregisterUdpSession_Params{Struct: s}) }
|
|
}
|
|
return SessionManager_unregisterUdpSession_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
|
|
type SessionManager_Server interface {
|
|
RegisterUdpSession(SessionManager_registerUdpSession) error
|
|
|
|
UnregisterUdpSession(SessionManager_unregisterUdpSession) error
|
|
}
|
|
|
|
func SessionManager_ServerToClient(s SessionManager_Server) SessionManager {
|
|
c, _ := s.(server.Closer)
|
|
return SessionManager{Client: server.New(SessionManager_Methods(nil, s), c)}
|
|
}
|
|
|
|
func SessionManager_Methods(methods []server.Method, s SessionManager_Server) []server.Method {
|
|
if cap(methods) == 0 {
|
|
methods = make([]server.Method, 0, 2)
|
|
}
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0x839445a59fb01686,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:SessionManager",
|
|
MethodName: "registerUdpSession",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := SessionManager_registerUdpSession{c, opts, SessionManager_registerUdpSession_Params{Struct: p}, SessionManager_registerUdpSession_Results{Struct: r}}
|
|
return s.RegisterUdpSession(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0x839445a59fb01686,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:SessionManager",
|
|
MethodName: "unregisterUdpSession",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := SessionManager_unregisterUdpSession{c, opts, SessionManager_unregisterUdpSession_Params{Struct: p}, SessionManager_unregisterUdpSession_Results{Struct: r}}
|
|
return s.UnregisterUdpSession(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
|
|
})
|
|
|
|
return methods
|
|
}
|
|
|
|
// SessionManager_registerUdpSession holds the arguments for a server call to SessionManager.registerUdpSession.
|
|
type SessionManager_registerUdpSession struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params SessionManager_registerUdpSession_Params
|
|
Results SessionManager_registerUdpSession_Results
|
|
}
|
|
|
|
// SessionManager_unregisterUdpSession holds the arguments for a server call to SessionManager.unregisterUdpSession.
|
|
type SessionManager_unregisterUdpSession struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params SessionManager_unregisterUdpSession_Params
|
|
Results SessionManager_unregisterUdpSession_Results
|
|
}
|
|
|
|
type SessionManager_registerUdpSession_Params struct{ capnp.Struct }
|
|
|
|
// SessionManager_registerUdpSession_Params_TypeID is the unique identifier for the type SessionManager_registerUdpSession_Params.
|
|
const SessionManager_registerUdpSession_Params_TypeID = 0x904e297b87fbecea
|
|
|
|
func NewSessionManager_registerUdpSession_Params(s *capnp.Segment) (SessionManager_registerUdpSession_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 3})
|
|
return SessionManager_registerUdpSession_Params{st}, err
|
|
}
|
|
|
|
func NewRootSessionManager_registerUdpSession_Params(s *capnp.Segment) (SessionManager_registerUdpSession_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 3})
|
|
return SessionManager_registerUdpSession_Params{st}, err
|
|
}
|
|
|
|
func ReadRootSessionManager_registerUdpSession_Params(msg *capnp.Message) (SessionManager_registerUdpSession_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return SessionManager_registerUdpSession_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) String() string {
|
|
str, _ := text.Marshal(0x904e297b87fbecea, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) SessionId() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) HasSessionId() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) SetSessionId(v []byte) error {
|
|
return s.Struct.SetData(0, v)
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) DstIp() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) HasDstIp() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) SetDstIp(v []byte) error {
|
|
return s.Struct.SetData(1, v)
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) DstPort() uint16 {
|
|
return s.Struct.Uint16(0)
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) SetDstPort(v uint16) {
|
|
s.Struct.SetUint16(0, v)
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) CloseAfterIdleHint() int64 {
|
|
return int64(s.Struct.Uint64(8))
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) SetCloseAfterIdleHint(v int64) {
|
|
s.Struct.SetUint64(8, uint64(v))
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) TraceContext() (string, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) HasTraceContext() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) TraceContextBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params) SetTraceContext(v string) error {
|
|
return s.Struct.SetText(2, v)
|
|
}
|
|
|
|
// SessionManager_registerUdpSession_Params_List is a list of SessionManager_registerUdpSession_Params.
|
|
type SessionManager_registerUdpSession_Params_List struct{ capnp.List }
|
|
|
|
// NewSessionManager_registerUdpSession_Params creates a new list of SessionManager_registerUdpSession_Params.
|
|
func NewSessionManager_registerUdpSession_Params_List(s *capnp.Segment, sz int32) (SessionManager_registerUdpSession_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 3}, sz)
|
|
return SessionManager_registerUdpSession_Params_List{l}, err
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params_List) At(i int) SessionManager_registerUdpSession_Params {
|
|
return SessionManager_registerUdpSession_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params_List) Set(i int, v SessionManager_registerUdpSession_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Params_List) String() string {
|
|
str, _ := text.MarshalList(0x904e297b87fbecea, s.List)
|
|
return str
|
|
}
|
|
|
|
// SessionManager_registerUdpSession_Params_Promise is a wrapper for a SessionManager_registerUdpSession_Params promised by a client call.
|
|
type SessionManager_registerUdpSession_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p SessionManager_registerUdpSession_Params_Promise) Struct() (SessionManager_registerUdpSession_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return SessionManager_registerUdpSession_Params{s}, err
|
|
}
|
|
|
|
type SessionManager_registerUdpSession_Results struct{ capnp.Struct }
|
|
|
|
// SessionManager_registerUdpSession_Results_TypeID is the unique identifier for the type SessionManager_registerUdpSession_Results.
|
|
const SessionManager_registerUdpSession_Results_TypeID = 0x8635c6b4f45bf5cd
|
|
|
|
func NewSessionManager_registerUdpSession_Results(s *capnp.Segment) (SessionManager_registerUdpSession_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return SessionManager_registerUdpSession_Results{st}, err
|
|
}
|
|
|
|
func NewRootSessionManager_registerUdpSession_Results(s *capnp.Segment) (SessionManager_registerUdpSession_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return SessionManager_registerUdpSession_Results{st}, err
|
|
}
|
|
|
|
func ReadRootSessionManager_registerUdpSession_Results(msg *capnp.Message) (SessionManager_registerUdpSession_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return SessionManager_registerUdpSession_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Results) String() string {
|
|
str, _ := text.Marshal(0x8635c6b4f45bf5cd, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Results) Result() (RegisterUdpSessionResponse, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return RegisterUdpSessionResponse{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Results) HasResult() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Results) SetResult(v RegisterUdpSessionResponse) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewResult sets the result field to a newly
|
|
// allocated RegisterUdpSessionResponse struct, preferring placement in s's segment.
|
|
func (s SessionManager_registerUdpSession_Results) NewResult() (RegisterUdpSessionResponse, error) {
|
|
ss, err := NewRegisterUdpSessionResponse(s.Struct.Segment())
|
|
if err != nil {
|
|
return RegisterUdpSessionResponse{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// SessionManager_registerUdpSession_Results_List is a list of SessionManager_registerUdpSession_Results.
|
|
type SessionManager_registerUdpSession_Results_List struct{ capnp.List }
|
|
|
|
// NewSessionManager_registerUdpSession_Results creates a new list of SessionManager_registerUdpSession_Results.
|
|
func NewSessionManager_registerUdpSession_Results_List(s *capnp.Segment, sz int32) (SessionManager_registerUdpSession_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return SessionManager_registerUdpSession_Results_List{l}, err
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Results_List) At(i int) SessionManager_registerUdpSession_Results {
|
|
return SessionManager_registerUdpSession_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Results_List) Set(i int, v SessionManager_registerUdpSession_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s SessionManager_registerUdpSession_Results_List) String() string {
|
|
str, _ := text.MarshalList(0x8635c6b4f45bf5cd, s.List)
|
|
return str
|
|
}
|
|
|
|
// SessionManager_registerUdpSession_Results_Promise is a wrapper for a SessionManager_registerUdpSession_Results promised by a client call.
|
|
type SessionManager_registerUdpSession_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p SessionManager_registerUdpSession_Results_Promise) Struct() (SessionManager_registerUdpSession_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return SessionManager_registerUdpSession_Results{s}, err
|
|
}
|
|
|
|
func (p SessionManager_registerUdpSession_Results_Promise) Result() RegisterUdpSessionResponse_Promise {
|
|
return RegisterUdpSessionResponse_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type SessionManager_unregisterUdpSession_Params struct{ capnp.Struct }
|
|
|
|
// SessionManager_unregisterUdpSession_Params_TypeID is the unique identifier for the type SessionManager_unregisterUdpSession_Params.
|
|
const SessionManager_unregisterUdpSession_Params_TypeID = 0x96b74375ce9b0ef6
|
|
|
|
func NewSessionManager_unregisterUdpSession_Params(s *capnp.Segment) (SessionManager_unregisterUdpSession_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
|
|
return SessionManager_unregisterUdpSession_Params{st}, err
|
|
}
|
|
|
|
func NewRootSessionManager_unregisterUdpSession_Params(s *capnp.Segment) (SessionManager_unregisterUdpSession_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
|
|
return SessionManager_unregisterUdpSession_Params{st}, err
|
|
}
|
|
|
|
func ReadRootSessionManager_unregisterUdpSession_Params(msg *capnp.Message) (SessionManager_unregisterUdpSession_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return SessionManager_unregisterUdpSession_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Params) String() string {
|
|
str, _ := text.Marshal(0x96b74375ce9b0ef6, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Params) SessionId() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Params) HasSessionId() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Params) SetSessionId(v []byte) error {
|
|
return s.Struct.SetData(0, v)
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Params) Message() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Params) HasMessage() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Params) MessageBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Params) SetMessage(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
// SessionManager_unregisterUdpSession_Params_List is a list of SessionManager_unregisterUdpSession_Params.
|
|
type SessionManager_unregisterUdpSession_Params_List struct{ capnp.List }
|
|
|
|
// NewSessionManager_unregisterUdpSession_Params creates a new list of SessionManager_unregisterUdpSession_Params.
|
|
func NewSessionManager_unregisterUdpSession_Params_List(s *capnp.Segment, sz int32) (SessionManager_unregisterUdpSession_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
|
|
return SessionManager_unregisterUdpSession_Params_List{l}, err
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Params_List) At(i int) SessionManager_unregisterUdpSession_Params {
|
|
return SessionManager_unregisterUdpSession_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Params_List) Set(i int, v SessionManager_unregisterUdpSession_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Params_List) String() string {
|
|
str, _ := text.MarshalList(0x96b74375ce9b0ef6, s.List)
|
|
return str
|
|
}
|
|
|
|
// SessionManager_unregisterUdpSession_Params_Promise is a wrapper for a SessionManager_unregisterUdpSession_Params promised by a client call.
|
|
type SessionManager_unregisterUdpSession_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p SessionManager_unregisterUdpSession_Params_Promise) Struct() (SessionManager_unregisterUdpSession_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return SessionManager_unregisterUdpSession_Params{s}, err
|
|
}
|
|
|
|
type SessionManager_unregisterUdpSession_Results struct{ capnp.Struct }
|
|
|
|
// SessionManager_unregisterUdpSession_Results_TypeID is the unique identifier for the type SessionManager_unregisterUdpSession_Results.
|
|
const SessionManager_unregisterUdpSession_Results_TypeID = 0xf24ec4ab5891b676
|
|
|
|
func NewSessionManager_unregisterUdpSession_Results(s *capnp.Segment) (SessionManager_unregisterUdpSession_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return SessionManager_unregisterUdpSession_Results{st}, err
|
|
}
|
|
|
|
func NewRootSessionManager_unregisterUdpSession_Results(s *capnp.Segment) (SessionManager_unregisterUdpSession_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return SessionManager_unregisterUdpSession_Results{st}, err
|
|
}
|
|
|
|
func ReadRootSessionManager_unregisterUdpSession_Results(msg *capnp.Message) (SessionManager_unregisterUdpSession_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return SessionManager_unregisterUdpSession_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Results) String() string {
|
|
str, _ := text.Marshal(0xf24ec4ab5891b676, s.Struct)
|
|
return str
|
|
}
|
|
|
|
// SessionManager_unregisterUdpSession_Results_List is a list of SessionManager_unregisterUdpSession_Results.
|
|
type SessionManager_unregisterUdpSession_Results_List struct{ capnp.List }
|
|
|
|
// NewSessionManager_unregisterUdpSession_Results creates a new list of SessionManager_unregisterUdpSession_Results.
|
|
func NewSessionManager_unregisterUdpSession_Results_List(s *capnp.Segment, sz int32) (SessionManager_unregisterUdpSession_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
|
|
return SessionManager_unregisterUdpSession_Results_List{l}, err
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Results_List) At(i int) SessionManager_unregisterUdpSession_Results {
|
|
return SessionManager_unregisterUdpSession_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Results_List) Set(i int, v SessionManager_unregisterUdpSession_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s SessionManager_unregisterUdpSession_Results_List) String() string {
|
|
str, _ := text.MarshalList(0xf24ec4ab5891b676, s.List)
|
|
return str
|
|
}
|
|
|
|
// SessionManager_unregisterUdpSession_Results_Promise is a wrapper for a SessionManager_unregisterUdpSession_Results promised by a client call.
|
|
type SessionManager_unregisterUdpSession_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p SessionManager_unregisterUdpSession_Results_Promise) Struct() (SessionManager_unregisterUdpSession_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return SessionManager_unregisterUdpSession_Results{s}, err
|
|
}
|
|
|
|
type UpdateConfigurationResponse struct{ capnp.Struct }
|
|
|
|
// UpdateConfigurationResponse_TypeID is the unique identifier for the type UpdateConfigurationResponse.
|
|
const UpdateConfigurationResponse_TypeID = 0xdb58ff694ba05cf9
|
|
|
|
func NewUpdateConfigurationResponse(s *capnp.Segment) (UpdateConfigurationResponse, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
|
|
return UpdateConfigurationResponse{st}, err
|
|
}
|
|
|
|
func NewRootUpdateConfigurationResponse(s *capnp.Segment) (UpdateConfigurationResponse, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
|
|
return UpdateConfigurationResponse{st}, err
|
|
}
|
|
|
|
func ReadRootUpdateConfigurationResponse(msg *capnp.Message) (UpdateConfigurationResponse, error) {
|
|
root, err := msg.RootPtr()
|
|
return UpdateConfigurationResponse{root.Struct()}, err
|
|
}
|
|
|
|
func (s UpdateConfigurationResponse) String() string {
|
|
str, _ := text.Marshal(0xdb58ff694ba05cf9, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s UpdateConfigurationResponse) LatestAppliedVersion() int32 {
|
|
return int32(s.Struct.Uint32(0))
|
|
}
|
|
|
|
func (s UpdateConfigurationResponse) SetLatestAppliedVersion(v int32) {
|
|
s.Struct.SetUint32(0, uint32(v))
|
|
}
|
|
|
|
func (s UpdateConfigurationResponse) Err() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s UpdateConfigurationResponse) HasErr() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s UpdateConfigurationResponse) ErrBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s UpdateConfigurationResponse) SetErr(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
// UpdateConfigurationResponse_List is a list of UpdateConfigurationResponse.
|
|
type UpdateConfigurationResponse_List struct{ capnp.List }
|
|
|
|
// NewUpdateConfigurationResponse creates a new list of UpdateConfigurationResponse.
|
|
func NewUpdateConfigurationResponse_List(s *capnp.Segment, sz int32) (UpdateConfigurationResponse_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
|
|
return UpdateConfigurationResponse_List{l}, err
|
|
}
|
|
|
|
func (s UpdateConfigurationResponse_List) At(i int) UpdateConfigurationResponse {
|
|
return UpdateConfigurationResponse{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s UpdateConfigurationResponse_List) Set(i int, v UpdateConfigurationResponse) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s UpdateConfigurationResponse_List) String() string {
|
|
str, _ := text.MarshalList(0xdb58ff694ba05cf9, s.List)
|
|
return str
|
|
}
|
|
|
|
// UpdateConfigurationResponse_Promise is a wrapper for a UpdateConfigurationResponse promised by a client call.
|
|
type UpdateConfigurationResponse_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p UpdateConfigurationResponse_Promise) Struct() (UpdateConfigurationResponse, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return UpdateConfigurationResponse{s}, err
|
|
}
|
|
|
|
type ConfigurationManager struct{ Client capnp.Client }
|
|
|
|
// ConfigurationManager_TypeID is the unique identifier for the type ConfigurationManager.
|
|
const ConfigurationManager_TypeID = 0xb48edfbdaa25db04
|
|
|
|
func (c ConfigurationManager) UpdateConfiguration(ctx context.Context, params func(ConfigurationManager_updateConfiguration_Params) error, opts ...capnp.CallOption) ConfigurationManager_updateConfiguration_Results_Promise {
|
|
if c.Client == nil {
|
|
return ConfigurationManager_updateConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xb48edfbdaa25db04,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:ConfigurationManager",
|
|
MethodName: "updateConfiguration",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 1}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(ConfigurationManager_updateConfiguration_Params{Struct: s}) }
|
|
}
|
|
return ConfigurationManager_updateConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
|
|
type ConfigurationManager_Server interface {
|
|
UpdateConfiguration(ConfigurationManager_updateConfiguration) error
|
|
}
|
|
|
|
func ConfigurationManager_ServerToClient(s ConfigurationManager_Server) ConfigurationManager {
|
|
c, _ := s.(server.Closer)
|
|
return ConfigurationManager{Client: server.New(ConfigurationManager_Methods(nil, s), c)}
|
|
}
|
|
|
|
func ConfigurationManager_Methods(methods []server.Method, s ConfigurationManager_Server) []server.Method {
|
|
if cap(methods) == 0 {
|
|
methods = make([]server.Method, 0, 1)
|
|
}
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xb48edfbdaa25db04,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:ConfigurationManager",
|
|
MethodName: "updateConfiguration",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := ConfigurationManager_updateConfiguration{c, opts, ConfigurationManager_updateConfiguration_Params{Struct: p}, ConfigurationManager_updateConfiguration_Results{Struct: r}}
|
|
return s.UpdateConfiguration(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
return methods
|
|
}
|
|
|
|
// ConfigurationManager_updateConfiguration holds the arguments for a server call to ConfigurationManager.updateConfiguration.
|
|
type ConfigurationManager_updateConfiguration struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params ConfigurationManager_updateConfiguration_Params
|
|
Results ConfigurationManager_updateConfiguration_Results
|
|
}
|
|
|
|
type ConfigurationManager_updateConfiguration_Params struct{ capnp.Struct }
|
|
|
|
// ConfigurationManager_updateConfiguration_Params_TypeID is the unique identifier for the type ConfigurationManager_updateConfiguration_Params.
|
|
const ConfigurationManager_updateConfiguration_Params_TypeID = 0xb177ca2526a3ca76
|
|
|
|
func NewConfigurationManager_updateConfiguration_Params(s *capnp.Segment) (ConfigurationManager_updateConfiguration_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
|
|
return ConfigurationManager_updateConfiguration_Params{st}, err
|
|
}
|
|
|
|
func NewRootConfigurationManager_updateConfiguration_Params(s *capnp.Segment) (ConfigurationManager_updateConfiguration_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
|
|
return ConfigurationManager_updateConfiguration_Params{st}, err
|
|
}
|
|
|
|
func ReadRootConfigurationManager_updateConfiguration_Params(msg *capnp.Message) (ConfigurationManager_updateConfiguration_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConfigurationManager_updateConfiguration_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Params) String() string {
|
|
str, _ := text.Marshal(0xb177ca2526a3ca76, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Params) Version() int32 {
|
|
return int32(s.Struct.Uint32(0))
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Params) SetVersion(v int32) {
|
|
s.Struct.SetUint32(0, uint32(v))
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Params) Config() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Params) HasConfig() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Params) SetConfig(v []byte) error {
|
|
return s.Struct.SetData(0, v)
|
|
}
|
|
|
|
// ConfigurationManager_updateConfiguration_Params_List is a list of ConfigurationManager_updateConfiguration_Params.
|
|
type ConfigurationManager_updateConfiguration_Params_List struct{ capnp.List }
|
|
|
|
// NewConfigurationManager_updateConfiguration_Params creates a new list of ConfigurationManager_updateConfiguration_Params.
|
|
func NewConfigurationManager_updateConfiguration_Params_List(s *capnp.Segment, sz int32) (ConfigurationManager_updateConfiguration_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
|
|
return ConfigurationManager_updateConfiguration_Params_List{l}, err
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Params_List) At(i int) ConfigurationManager_updateConfiguration_Params {
|
|
return ConfigurationManager_updateConfiguration_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Params_List) Set(i int, v ConfigurationManager_updateConfiguration_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Params_List) String() string {
|
|
str, _ := text.MarshalList(0xb177ca2526a3ca76, s.List)
|
|
return str
|
|
}
|
|
|
|
// ConfigurationManager_updateConfiguration_Params_Promise is a wrapper for a ConfigurationManager_updateConfiguration_Params promised by a client call.
|
|
type ConfigurationManager_updateConfiguration_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConfigurationManager_updateConfiguration_Params_Promise) Struct() (ConfigurationManager_updateConfiguration_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConfigurationManager_updateConfiguration_Params{s}, err
|
|
}
|
|
|
|
type ConfigurationManager_updateConfiguration_Results struct{ capnp.Struct }
|
|
|
|
// ConfigurationManager_updateConfiguration_Results_TypeID is the unique identifier for the type ConfigurationManager_updateConfiguration_Results.
|
|
const ConfigurationManager_updateConfiguration_Results_TypeID = 0x958096448eb3373e
|
|
|
|
func NewConfigurationManager_updateConfiguration_Results(s *capnp.Segment) (ConfigurationManager_updateConfiguration_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return ConfigurationManager_updateConfiguration_Results{st}, err
|
|
}
|
|
|
|
func NewRootConfigurationManager_updateConfiguration_Results(s *capnp.Segment) (ConfigurationManager_updateConfiguration_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return ConfigurationManager_updateConfiguration_Results{st}, err
|
|
}
|
|
|
|
func ReadRootConfigurationManager_updateConfiguration_Results(msg *capnp.Message) (ConfigurationManager_updateConfiguration_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConfigurationManager_updateConfiguration_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Results) String() string {
|
|
str, _ := text.Marshal(0x958096448eb3373e, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Results) Result() (UpdateConfigurationResponse, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return UpdateConfigurationResponse{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Results) HasResult() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Results) SetResult(v UpdateConfigurationResponse) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewResult sets the result field to a newly
|
|
// allocated UpdateConfigurationResponse struct, preferring placement in s's segment.
|
|
func (s ConfigurationManager_updateConfiguration_Results) NewResult() (UpdateConfigurationResponse, error) {
|
|
ss, err := NewUpdateConfigurationResponse(s.Struct.Segment())
|
|
if err != nil {
|
|
return UpdateConfigurationResponse{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// ConfigurationManager_updateConfiguration_Results_List is a list of ConfigurationManager_updateConfiguration_Results.
|
|
type ConfigurationManager_updateConfiguration_Results_List struct{ capnp.List }
|
|
|
|
// NewConfigurationManager_updateConfiguration_Results creates a new list of ConfigurationManager_updateConfiguration_Results.
|
|
func NewConfigurationManager_updateConfiguration_Results_List(s *capnp.Segment, sz int32) (ConfigurationManager_updateConfiguration_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return ConfigurationManager_updateConfiguration_Results_List{l}, err
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Results_List) At(i int) ConfigurationManager_updateConfiguration_Results {
|
|
return ConfigurationManager_updateConfiguration_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Results_List) Set(i int, v ConfigurationManager_updateConfiguration_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
func (s ConfigurationManager_updateConfiguration_Results_List) String() string {
|
|
str, _ := text.MarshalList(0x958096448eb3373e, s.List)
|
|
return str
|
|
}
|
|
|
|
// ConfigurationManager_updateConfiguration_Results_Promise is a wrapper for a ConfigurationManager_updateConfiguration_Results promised by a client call.
|
|
type ConfigurationManager_updateConfiguration_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConfigurationManager_updateConfiguration_Results_Promise) Struct() (ConfigurationManager_updateConfiguration_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConfigurationManager_updateConfiguration_Results{s}, err
|
|
}
|
|
|
|
func (p ConfigurationManager_updateConfiguration_Results_Promise) Result() UpdateConfigurationResponse_Promise {
|
|
return UpdateConfigurationResponse_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type CloudflaredServer struct{ Client capnp.Client }
|
|
|
|
// CloudflaredServer_TypeID is the unique identifier for the type CloudflaredServer.
|
|
const CloudflaredServer_TypeID = 0xf548cef9dea2a4a1
|
|
|
|
func (c CloudflaredServer) RegisterUdpSession(ctx context.Context, params func(SessionManager_registerUdpSession_Params) error, opts ...capnp.CallOption) SessionManager_registerUdpSession_Results_Promise {
|
|
if c.Client == nil {
|
|
return SessionManager_registerUdpSession_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0x839445a59fb01686,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:SessionManager",
|
|
MethodName: "registerUdpSession",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 16, PointerCount: 3}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(SessionManager_registerUdpSession_Params{Struct: s}) }
|
|
}
|
|
return SessionManager_registerUdpSession_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c CloudflaredServer) UnregisterUdpSession(ctx context.Context, params func(SessionManager_unregisterUdpSession_Params) error, opts ...capnp.CallOption) SessionManager_unregisterUdpSession_Results_Promise {
|
|
if c.Client == nil {
|
|
return SessionManager_unregisterUdpSession_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0x839445a59fb01686,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:SessionManager",
|
|
MethodName: "unregisterUdpSession",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 2}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(SessionManager_unregisterUdpSession_Params{Struct: s}) }
|
|
}
|
|
return SessionManager_unregisterUdpSession_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c CloudflaredServer) UpdateConfiguration(ctx context.Context, params func(ConfigurationManager_updateConfiguration_Params) error, opts ...capnp.CallOption) ConfigurationManager_updateConfiguration_Results_Promise {
|
|
if c.Client == nil {
|
|
return ConfigurationManager_updateConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xb48edfbdaa25db04,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:ConfigurationManager",
|
|
MethodName: "updateConfiguration",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 1}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(ConfigurationManager_updateConfiguration_Params{Struct: s}) }
|
|
}
|
|
return ConfigurationManager_updateConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
|
|
type CloudflaredServer_Server interface {
|
|
RegisterUdpSession(SessionManager_registerUdpSession) error
|
|
|
|
UnregisterUdpSession(SessionManager_unregisterUdpSession) error
|
|
|
|
UpdateConfiguration(ConfigurationManager_updateConfiguration) error
|
|
}
|
|
|
|
func CloudflaredServer_ServerToClient(s CloudflaredServer_Server) CloudflaredServer {
|
|
c, _ := s.(server.Closer)
|
|
return CloudflaredServer{Client: server.New(CloudflaredServer_Methods(nil, s), c)}
|
|
}
|
|
|
|
func CloudflaredServer_Methods(methods []server.Method, s CloudflaredServer_Server) []server.Method {
|
|
if cap(methods) == 0 {
|
|
methods = make([]server.Method, 0, 3)
|
|
}
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0x839445a59fb01686,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:SessionManager",
|
|
MethodName: "registerUdpSession",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := SessionManager_registerUdpSession{c, opts, SessionManager_registerUdpSession_Params{Struct: p}, SessionManager_registerUdpSession_Results{Struct: r}}
|
|
return s.RegisterUdpSession(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0x839445a59fb01686,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:SessionManager",
|
|
MethodName: "unregisterUdpSession",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := SessionManager_unregisterUdpSession{c, opts, SessionManager_unregisterUdpSession_Params{Struct: p}, SessionManager_unregisterUdpSession_Results{Struct: r}}
|
|
return s.UnregisterUdpSession(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xb48edfbdaa25db04,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/proto/tunnelrpc.capnp:ConfigurationManager",
|
|
MethodName: "updateConfiguration",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := ConfigurationManager_updateConfiguration{c, opts, ConfigurationManager_updateConfiguration_Params{Struct: p}, ConfigurationManager_updateConfiguration_Results{Struct: r}}
|
|
return s.UpdateConfiguration(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
return methods
|
|
}
|
|
|
|
const schema_db8274f9144abc7e = "x\xda\xccZ}t\x14\xd7u\xbfw\xde.#\xc9\x12" +
|
|
"\xbb\xe3\xd9\x04!E^G\x07\xda\x9a\x04cAIm" +
|
|
"\x9aD\x12\x96\x88\x85\x01k\xb4\x90\xe3\x83q\x8eG\xbb" +
|
|
"O\xd2\xa8\xbb3\x9b\x99Y\x19\x11;|\x04\x8c\xf1\xb1" +
|
|
"\x1dC\xc06Jh\x08\x8e\xdbS9IM\x8c\x9b\xa6" +
|
|
"\xc7nM\x1a\xc7\x89\x1d\x13\xe3cR\x08N\xd3\x94\xd0" +
|
|
"6>\xa4\xae\xbf\x9a\xc3i\xea\xe9\xb93;\x1f\xda\x15" +
|
|
"H\x82\xf6\x9c\xfe\x07w\xef\xbc\xf7\xee\xef\xfd\xee}\xbf" +
|
|
"w\x9f\xae{\xb1\xb6Ch\x8boN\x00(G\xe2\xb3" +
|
|
"\x1c\xbe\xe0\xd5M\x07\xe7\xff\xfd6P\xaeFt>\xff" +
|
|
"\xcc\xca\xd4y{\xdbi\x883\x11`\xc9\xe3\xe28\xca" +
|
|
"\xcf\x8a\"\x80\xfc]\xf1_\x01\x9d{>\xf8\xe4W\x1f" +
|
|
"\xef\xde\xfb\x05\x90\xaef\xa13\xe0\x92\x035\x9bP>" +
|
|
"\\C\x9e\xdf\xac\xd9)7\xd4\x8a\x00\xce\xcd\xd2\xa2\xdb" +
|
|
"R\xaf\x1c#\xef\xe8\xd01\x1a\xfa\xbd\x9a\xf5(\xd7\x92" +
|
|
"\x9b\x1c\xaf\xa5\xa1?^\xf8\xc9\xa1\x8f\xed{i;H" +
|
|
"W\x0b\x13\x86~\xabv\x1c\xe5\xda:\xd7\xb3\xee\x16@" +
|
|
"\xe7\x9d\xbd\x8dO|\xed\xd8\x0fw\x80\xb4\x10\xa1\xbc\xd2" +
|
|
"\x96\xba:\x01P^Z\xf7\x97\x80\xce\xcb\xef\xdd\xf6\xee" +
|
|
"\x91\x1f,\xbd\x07\xa4E\xe4\x80\xe4p\xa2\xae\x8f\x1c\xde" +
|
|
"\xaak\x07t\xde8\xf7_;?w\xcd\x9a\x87@Y" +
|
|
"\x84\x82?\x84t\xc5J\x01p\xc9\xc2+\xd2\x08\xe8\xb4" +
|
|
"\xafx\xf9\xbbMK\x1e\xde[\xb1v\x81<\x95\xfa\xf5" +
|
|
"(\xf3zZ\x91Z\x7f'\xa0\xf3\xc9?z\xea\xc1\xae" +
|
|
"\x87\xb7\xec\x03ii0\xe1\xf3\xf5\xf7\xd1\x84g\xebi" +
|
|
"\xc2\xff\x9c\xfd\xe5c\xa5\x1b\xbf\xf3pyE\xee(\xf1" +
|
|
"\x86\xf5\xe4\xf0\xe1\x06\x1a\xa1ud\xfe\x1d\xdf{\xfe\xa9" +
|
|
"G@Y\x82\xe8\xbc\xde\xff\x91\x13\xec\xc0\xf8iX\x87" +
|
|
"\"-p\xc9\xd6\x86W\x11P\xde\xe7\xfa\xfe\xe4\xa3\xcf" +
|
|
"\xfc\xcdCO\xed\xfc2(\x0b\x11\x01\\8\xcf7," +
|
|
"\xa0\xc1\xa4\xd94\xdb\xde\x93\xcf\xae)\xec\x1e;\xe4\x01" +
|
|
"\xe4\xfe~\xc3\xec\xc5\x02\xc4\x9c\xed=\xbf-\xac{," +
|
|
"\xf3X\x19\xba8\xfd\xd46\xbb\x95\xe2\xee\x99\xed\xc6\xbd" +
|
|
"\xf4ggoY\xfd\xed\x81?\x8f|\xcb\x13\xe3\xf4\xed" +
|
|
"\xce\x81\xb7\x8f&\xfb\x0aOL\x86\x08O\xfc\x0c\xe5\xad" +
|
|
"\x09B\xe4\xee\x04\xad\xf1\x9bW\xdd\\\xbb\xf1\xec\x8a'" +
|
|
"AZ\xe2\x0fs*\xb1\x8d\x86\x19y\xf1\xb1\xdf\x9b\xff" +
|
|
"\xe2\x9d\x87AY\x8a\xe1\xee\xd0o(\xbf\xe5~\x1b;" +
|
|
"=\x7f\xfc\xd9_<x\xa4\x8ad\xab\x93\xe3(\xf3\xa4" +
|
|
"\x8b{\xf2S\xf2n\xfa\x97\x13\xbb\x9d\xbd\xaf>\xfaw" +
|
|
"G*\x09\xec\xaek4\xb9\x07=\xbf%\x0f$\xdd\xf8" +
|
|
"\xee;:\xf6\x91\x9a\xaf\xbe\xf3\xf4\xa4\xeeOK{P" +
|
|
"~Y\xa2\x09~$\x11\x93>\xd0\x83\xaf?\xd7\x16\xfb" +
|
|
"N\x94j\x85+\x9bh\xad;\xae$\x87\x96\xdf,o" +
|
|
"\xd0\xdf\xdc\xf6\\\x05(\xae\xe3|y\x13\xca7\xc84" +
|
|
"\xdaR\x99\x9cc\x1f\x1b\xde)\x9d\xf9\xe9\xf3\x1e(^" +
|
|
"\xe4\xc7\xe517r\x996n\xe5m_\xda\x13?\xfb" +
|
|
"\xa5\x17hq\x91$\x88\xd7\xb8\xfcL\x1dB\xf9\x9a\x94" +
|
|
";rj\x0e\x03t\x9a\x9e\xfc\xe3o-\xcf\x9dzi" +
|
|
"\xb2\x1dy|N+\xcaO\xcf\xa1\xc9\x0f\xcf!T\xcf" +
|
|
",<\xfc\xb9_?p\xfc\xb5r(\xee\xe4\x0d\x8d." +
|
|
"k\xe67\xd2\xe4\xe77\x1c\xbcYsn=]\x89\x8c" +
|
|
"\xeb\xd9\xdd\xf8\xcf(\xab\x8d4\xdc\xed\x8d4\\@\xd1" +
|
|
"\xc9\xbc\x8f6\x8e\xa1|\xca\xf5>\xe1\x8e-\x9cU\xe7" +
|
|
"n\xf9\xe9'_\x8f\xb0\xeaT\xe3\x95D\x875\x9f\xbe" +
|
|
"m\xb8\xf6\xee3g\xa2\xcb:\xde\xe8\"\xfck\xf7\xd3" +
|
|
"\xbf\xfd\x87G\x86n\xff\xd6\xb1\xb3\x11&\xd5\xce=D" +
|
|
"\x9f\xfe\xfb\x9f\xbd\xf1\xc5s\x85\xdc\xbf\xb89\xe3\xefN" +
|
|
"\xed\xdca7\xa4\xb9TS\xe6\xa4\x1b\xba[O\xf6\xbe" +
|
|
"\x11\x05\x1c\x9bLrhi\xa2\xc1\x97\xde\xd1\xc97\\" +
|
|
"\x7f\xeb\x1bUT\xfbD\xd30\xcaJ\x13}\xb0\xbai" +
|
|
"'\xca\xbcy\x0e\x803\xf2W\xbbo}\xe2\xfbk\xde" +
|
|
"\xf6\xd2\xd8]\xcb\xba\xe6~Z\xcb\x83\x9f\xef\xba\xe5\x86" +
|
|
"\xd6\xa3oG\xc3P\x9a)\xb1d\xad\x99f\x1a\xb8\xfe" +
|
|
"\xdc\xa7\xe6?\xf8\x83\xb7+\xf6\xcau\xdc\xd5\xbc\x1e\xe5" +
|
|
"\x03\xcd\x04\xd7~r~s\xc5\x9f\xbe\xd6\x94hz\xb7" +
|
|
"\x02\xdaY\xe4\xfbl\xf3\x18\xca'\x9a]\x98\x9a_ " +
|
|
"F\x7f\xed\xeb\x87\xfe\xf1\xfc\xb1\x9b\xde\xab\x8a\xe1\xf9\x96" +
|
|
"=(\xff\xbc\x85\x86=\xd5\"\xca\xa7Z~\x1f\xc0\xb9" +
|
|
"\xe7\xf4g6\xbe\xfa\x85w\xde\xab\xa4\x98\x07|\xcb6" +
|
|
"\x94\xcf\xba_\xfc\xb2\x85\x18\xfb\xc8\xda\x7f\xdb|n\xdf" +
|
|
"\x07\x7f[5\xf6\xd6\xab\xc6P\xde\x7f\x15y\xee\xbb\xea" +
|
|
"\x05\xf9\x9a4\xa5\xe2+\xe2cm]\x9b_:\x1f\xd9" +
|
|
"*)\xbd\x89\xe0yX\xfc\xca\x99-\xbf\xf8\xcc\xef&" +
|
|
"\x90/}\xa5\xbbSi\x82\xe7\xae7\xf7\xdf\xf4\xc5\x0d" +
|
|
"\xdfx?B\x90\xee\xf4\xb7\xe9S\xbb\xa4\xeb<o\x16" +
|
|
"\xe3\xd9EE\xd3\xb0\x8dE\xbe!{mV-\xea\xc5" +
|
|
"e\x9d%{\x88\xeb\xb6\x96Um\xde\xc7\xadb\xc2\xd0" +
|
|
"-\xde\x8b\xa8$Y\x0c \x86\x00\x92:\x0c\xa0\xdc\xc1" +
|
|
"P\xc9\x0b(!\xa6\x88.\x92F\xc6!\x86\x8a-\xa0" +
|
|
"$\x08)*\xb4\xd2g[\x01\x94<Ce\xa3\x80\xc8" +
|
|
"R\xc8\x00\xa4\xd2\x1e\x00e#Ce\xbb\x80N\x91\x9b" +
|
|
"\x05U\xe7:$\xecn\xd3\xc4z\x10\xb0\x1e\xd01\xb9" +
|
|
"m\x8e\xaa\xfdyH\xf0\x88Y\x1c\xbe\xd3\xc6\x06\x10\xb0" +
|
|
"\x01\xd0\x192J\xa6\xb5N\xb7Q\xcb\xf7\xf1\x01\x93[" +
|
|
"8\x84\xb3@\xc0Y\x80A\x90\xb1\x0b\x05\x99\xe1\x96\xa5" +
|
|
"\x19\xfa\xeavUW\x07\xb9I\xe1\xd5\xb08@p\x94" +
|
|
"\xa1\x7f\xe8Imc H\x0bE\x0cO\x1d\xf4y+" +
|
|
"}x\x1c\x04\xa9EtL>\xa8Y67q]\xae" +
|
|
"\xe8\x0e\xcd\x0c\xbd\x03\x9d\x92\xee\xfd\x80\xdc\xf4~H\xd0" +
|
|
"\xa4\x1d\xd8\x8b\xd3X\xe2\x8dy\x8d\xebv\x8f\xce\x06\x8c" +
|
|
"\x0a\xf4WN\x86\xfe\xca2\xfa\xdb#\xe8o]\x0e\xa0" +
|
|
"\xdc\xc5P\xb9W@\x89\x95\xe1\xdf\xb1\x00@\xd9\xc2P" +
|
|
"\xb9_@'\xebM\x92\x03\x80\x00\xd8\x01\xae\xda%\x93" +
|
|
"[d\x9b\x0d\xd8\xcb\xd0\xc5\x7f6\xe0\xe6\x11nR\x04" +
|
|
"\xfe~$T3;\x14\xec\xd9\x94\xcc\xea\xde\xa8Y\xb6" +
|
|
"\xa6\x0f\xaeu\xed\xbdF\"\xafeG)\xb6zw\xb5" +
|
|
"-\xcb\x00\x10\xa5\x0f\xac\x07@A\x92\x96\x03\xb4k\x83" +
|
|
"\xbaar'\xa7YYC\xd79\xb0\xac\xbd\xb9_\xcd" +
|
|
"\xabz\x96\x07\xd3\x89\x17\x9a\xce\x9b&\xc3\xcd\x11n^" +
|
|
"\xabFX=\xafW5\xd5\x82\x05\xa0\xd4\x07\xa0v\xaf" +
|
|
"\x07P\xba\x18*\xbd\x11PW\x13\xa8\xab\x18*\xb7F" +
|
|
"@]G\xa0\xf62T6\x08\xe8\x18\xa66\xa8\xe97" +
|
|
"r`f\x94\x99\x96\xad\xab\x05N\x00\x96\xc1\xd9l\x14" +
|
|
"m\xcd\xd0-L\x86\x87\x12 &#\xb0\xd5L\xc5U" +
|
|
"\x8f\xaa\xd7\xfa\\\xf3\xa9f\xe8\xf3\xfa\xb8U\xca\xdbh" +
|
|
")\xb1 \x9e\x86e\x00J\x0dC%%`\xbb\xe9\xfd" +
|
|
"\x9e\x0c5\xc7\xff\xde\xdc\x01\x96\xa9`\xee\xbb\xfb\"\xb4" +
|
|
"\xf3\xb1\xdc\xb18\xa4\x1d\x96\xa1\xdcEPng\xa8<" +
|
|
"D\xfcD\x8f\x9f\x0f\x8c\x01(\x0f1T\xbe\"\xa0\x14" +
|
|
"\x13R\x18C\x94\xf6Sqy\x94\xa1\xf2u\x01\x1d\xcb" +
|
|
"\x9b\xba\x070\xe7c\x9e\xceYvO\xd1\xff\xdf\xe6\x9c" +
|
|
"e\xf7\x1a\xa6\x8d\"\x08(\x02\xd1\xdc\xb0x\xe7\x00%" +
|
|
"bO.\xcfo\xd2\x98nc\x1c\x04\x8c\x13\x08\xa6\x9a" +
|
|
"\xe57\x1aT\x82\xf8F\xbb\xbcc a\x1d\xc0\xd4Y" +
|
|
"\xea\x91\xac\xb3\xc4\xec!\xaf\x88\xf8 \\C\x84\xfa\x03" +
|
|
"\x86\xca\x1fF@h\xa30\xaec\xa8|\\@G\xcd" +
|
|
"f\x8d\x92n\xaf\x05\xa6\x0eV$Q\x86C\"k\xf2" +
|
|
"\x90R\xfe\xb4\xb5\x17\xac\x16\x86>\xa0\x0d\x96L\xd5\x8e" +
|
|
"lW\xa9\x98Sm>\xe1\xa72Wh\xc3\xa6\"K" +
|
|
" `.\x91,~\xf5\xab\xa2\x0b+XQ\xa0\xfa&" +
|
|
"\x03\x8a\x98\xf1Q\x86\xca\xf5\x93\xef\xf7\xe6\x02\xb7,u" +
|
|
"\x90W\x15\x9fY\x17\x01H\xe7Y\x82\x80\x0e5:\xd3" +
|
|
"\xaeu#E\x9b\xd6R\xef8\xdeb\x88\xa5\xf3\x18*" +
|
|
"\xd7\x09\xd8\x80\xef;\xdej\x16\xee\x09\xb7-\xcdM\xd3" +
|
|
"01\x19\x9e\xfcex\xb2\xe5\x09\xd0\xd0\xbb\xb8\xadj" +
|
|
"y\xa4l\x0f\xf4q\x05\x88\xd3\xabZ!\x84\x9ey^" +
|
|
"\xaf\x9a\xa0t\x8b\xee\x1d\xa5K\x92\xa1\xf2!\x01\x9dA" +
|
|
"\xa2r/7Q3rkT\xdd\xc80\x9e\x0dy~" +
|
|
"yS\xf7\xf1\xb4\xcb\x9c\x19\x8ec\xf220A\x04\xa6" +
|
|
"H\x11D\xcaEk\xa8\x07\x02\x02l\xed\x0f\xcbEP" +
|
|
"zwQN\xdd\xcbP\xd9\x1b9\xcfv\xaf\x8c\xd6\x8b" +
|
|
"X\x0ac\x00\xd2~\xe2\xcf^\x86\xcaAa\xa2j\xe0" +
|
|
"#\\\xb7\xbb\xb4A\x10\xb9\x15Zi\x89]\xda \x07" +
|
|
"f]n\x19\xaf\x9d\x16*F\xbfe\xe4\xb9\xcd\xbbx" +
|
|
"6\xafRf\x8ep\xef\xf72M\xfd\x8d\x9e\x9a\xd7}" +
|
|
"U9\xe6\xf1\x9by\xa2-\x92g\xad!\xb5\x03\x98\x17" +
|
|
".\x0e\x93O\xe4\xa1\xd2J[EU\xb7\xaa\xca\x8f|" +
|
|
"\xf1Ux%\xa6\x8a@a\xea\x05\xd5'\xf8\xfer\xcb" +
|
|
"Y\xf9\xf8\x89\xc6\xb9<\x8c3\x08sY\x18f b" +
|
|
"b `\x0c\xb0=\xeb\x0eX\x15k|\xbakK\xf8" +
|
|
"\x0a2\xe6*H\xffB\x8e~\x17C\x92\x0e\x81 5" +
|
|
"\x88\x8e\xbf~\xf4\xbf\x17\xab\xd4`|\xea\xf2u\x8bK" +
|
|
"A\xb4h\xc6H\x12-\x9b,\x89\xccI\xce\xdcm\xd1" +
|
|
"\x1c*\x9f\xb9\xbb\xc7\xc2t\xf1\xce\\\x00\xe9\xc0!\x00" +
|
|
"\xe5 C\xe5\x1b\x02\xb6{B\x11\x93a\x13\xaa\xcc{" +
|
|
"O\x01\xad2 \x9dU\xf3\xe1\x11\xec\x98\xbc\x98W\xb3" +
|
|
"\xbc\x1b\xcb\xa2\x0f\x10A@t\x93\xadP4\xb9e\xa1" +
|
|
"f\xe8JI\xcdk\xcc\x1e\x0d\x94\xbb^*\xf4\x9a|" +
|
|
"DC\xa3du\xda6/\x88E\xdb\xaa\xd2\xf5\xd3\x80" +
|
|
"\xc9\xaf\xc1\xae\xbe\x0ce\x1e\x89\xdf\x0e\x86\xca\xaa\x08L" +
|
|
"=t*\xdf\xc4PY\x1b\xc2\xa4|\x0f@Y\xcbP" +
|
|
"\xb9C\xc0D\xa9\xa4\x05'\x8f\x937\xb2\xee\xceCb" +
|
|
"\x8dZ\xa8<\x80z,\xa1\x8f\x17\x0c\x9b\xe7G=\xd6" +
|
|
"\xe6\xc2\xb8gZ7+\x0a\xbfwn\xfe\x7fR\xac\xb1" +
|
|
"\xa9\xae\x90\xed\x1eR\x15[\xd0:\xd9\x16,\x8e\x04\xe3" +
|
|
"\xaf{u\x7f\x18\x8c\xf8'|4(N\xbc@[\xeb" +
|
|
"#_\x8e\xa8\x13\xc4\x9bC\x9f\xa9\xeb\xf1d%\xcbM" +
|
|
"\xd0UFV\xcdWW\x19V\xb8\xa0\xbe\x9ei\x05\x89" +
|
|
"NM\xe9,\x1a\xba\xcb\xd3\xeb\xfd\xe1\xe5Q\\\x09\x90" +
|
|
"\xd9\x88\x0c3\xdb1\xc4I\xde\x8a\xcb\x012w\x91\xfd" +
|
|
"^\x0c\xa1\x92w`\x13@f\x0b\xd9\xef\xc7\xe0\xaa-" +
|
|
"\xef\xc2q\x80\xcc\xfdd~\x94\xdcc\xccMmy\x9f" +
|
|
";\xfc^\xb2\x1f${<\x96\xc28\x80|\x00\x17\x00" +
|
|
"d\x1e%\xfb\x11\xb2\xcf\x12R8\x0b@>\x8c\xc3\x00" +
|
|
"\x99'\xc9\xfe\x0c\xd9\xc5x\x0a\xdd.6\x9a\x00\x99\xbf" +
|
|
"&\xfb\xf7\xc9^\xd3\x98\xc2\x1a\x00\xf9\xa8k\x7f\x8e\xec" +
|
|
"?&{\xed\xdc\x14\xd6\x02\xc8?\xc2m\x00\x99\x1f\x92" +
|
|
"\xfd5\xb2\xd7a\x8ad\xb6|\x1c\xc7\x002\xaf\x91\xfd" +
|
|
"\x9f\xc8~\xc5\xac\x14^\x01 \xff\xdc]\xcfI\xb2\xff" +
|
|
"\x8a\xec\xf5\xb1\x14is\xf9\x97x\x08 \xf3+\xb2\xff" +
|
|
"\x07\xd9\x1b\xc4\x146\x00\xc8\xbfq\xe3:G\xf6\x1a\xa1" +
|
|
"\xe2z\xeb\xf3\xba\xe2\x0e\xcb\x0c+\xe0\x0c/\xd7*\x9c" +
|
|
"pC\xc5D\xd8L\x07\xc4\x04\xa0S4\x8c\xfc\x9a\x89" +
|
|
"\xf9\x92\xb0\xd5A\xcb\xbf/'\xc3^\" \x19\x03u" +
|
|
"\x08\x09C\xef\xc9\x05\x05\xad\xb2z\xfa+\xd1\xac\xce\x92" +
|
|
"m\x94\x8a\x90&F\xe6\x82\x1ab\x96\xf4\x15\xa6QX" +
|
|
"\x8b\xdc,h\xba\x9a\x9f\xa2\xaa\xd6\x82\x80\xb5P.`" +
|
|
"\xfe\xd8\x17/\xb1\x17\xbe\xfd\x07\xbcf\x17\xe2\xb5\xb8V" +
|
|
"\x1d\xac\x10\x1d\x0b\xa6\x10\x1d\x09=RD\xd3#j\xbe" +
|
|
"T\xad\xe9/Mh\xf6q+AZc\xaa{\x8e\xdf" +
|
|
"\x1d\xac(n\x17\x14\\\xeb\xaaU\x88\xab\xb8D\xbdJ" +
|
|
"q\x8d\x87\x97\x18?\xf6\xa5\xad\x91\x1b`^\xb5\xb9e" +
|
|
"w\x16\xb1\x98\xd7x\xee\xd3\xdcLD\x85IT\x8f\xcd" +
|
|
"\xe4\xe4\x9b\xa0\xff\xdc\xe01\xf2 B \x08\xe5\xe0g" +
|
|
"\x88\xf0 \xb7\xbd\x7f\xf5\xe8\x03\x86\xa7\xbc\xd0\xba\xac1" +
|
|
"\\9\xc8\xa6\xde\xa3\xb0\xdd;]\xb5=\x93\xeaN\xab" +
|
|
"\x10\xa37\x9b\x9a\x19\x8c:\x89\xc8\xf5/i\x91\x96\x1d" +
|
|
"\xa5\xc1\x06\x86\xcaP$\x0d8\x9d\xd59\x86J1\x94" +
|
|
"\x1d\x85\xbe\xb0_*1\xa1\xdc0\xa5\xf3\xbb\xc8P\xb9" +
|
|
"K\xc0\x84Z\xb2\x870\x19\xbe\xa7M\x00db#\x8f" +
|
|
"\xf2\xa1G\xcfq\xc0\x8d~zGN\xf5\xe0\xa1g\xba" +
|
|
"\xd7\xfb\xe9\x05\xef_\x13\xa7\xdc\xd2\xe0\xc5c\xba\xaa\xc2" +
|
|
"\xe7Q\x82\xa6&n7\xbaz\xdb\x7fSB\xff\xcd@" +
|
|
":\xbc\x09\x04\xe9/D\x0c\xdfI\xd0\x7f\x16\x91\x0e\x98" +
|
|
" H\xfbD\x14\x82g?\xf4\x9f\xf7\xa4]\xf7\x81 " +
|
|
"\xed\x10\x91\x05\xafv\xe8\xf7\xd1\xdbF\xeb\x10\x04\xe9n" +
|
|
"\x11c\xc1{)\xfa]x\xe9\xb3\xc3 H\x9a\x88\xf1" +
|
|
"\xe0A\x10\xfd\xe7!\xe9\xf6m H\xeb\xc2\x161\xb4" +
|
|
"{qt\xa0\xe3\xe7\x02\xa4\xddl\x98\xd80\xf6\xbc\x00" +
|
|
":\xd0\xf1/\x8b\xecB\xb7E\xd7\xcb\xefpB\"\xab" +
|
|
"\xda\xbc\x83\x14\xb8W\x10\xb1\\\x11\xa1\x03\x95\x18F\x1e" +
|
|
"!\"\xfd\xad\xcb\xea\xe9T\xe5\xcf%)\\\x7f\x94K" +
|
|
"\xac\xd7\x17i\xf5{\xe5\xa6\xdcG\x8f\x8c>\xecv\x80" +
|
|
"Qi\x14\xa6P\xf5\x17)\xbb\xde\xe2\xc3\xd4`\x9e\xdc" +
|
|
"\xbd:\x98\xe58\x15\xfc\x1f3TNFR\xff\x04\x19" +
|
|
"_a\xa8\xbc\x1e\x91\xbb\xa7\xa8\x1e\x9cd\xa8\xbc\x1b\xbe" +
|
|
"\x95\xbcu\x1f\x80\xf2.\xc3\xbe\x88z\x93\xfe\x9b\x1c\x7f" +
|
|
"G\x1a\xc7\xd5n\xe8i\xb78\xee\x01\xc8\xd4\x90\xf6I" +
|
|
"\xb9\xda-\xe6i7\x09\xfb\x012I\xb2\x7f(\xaa\xdd" +
|
|
"\xe6\xe2z\x80L#\xd9\xe7\xe1\xc4\xdb\xbfX2Cy" +
|
|
"\x9d7\x06Wi\xfa\xa4\x82\xc0\x7f\xbcA{\x85\xaa\xe5" +
|
|
"K&\x87\xca\xdbNOWD\"y\xaf:^\x1b6" +
|
|
"C\xe4\xcc\xa1\x15\xb4hg\xd0\x98\x99\xfa,\xcc\x1b\xa5" +
|
|
"\xdc@^5y\xce\xdd}\xa4r\xd1\xcb\xe2J\x0dF" +
|
|
"\xfe\xe6\x02 |\x1a\x8f\xa4\xc24N\xd8n\xd34L" +
|
|
"\xa8\xb8\xd6,\x0e\xaf5\xc1\xadf}x\xb1\x94\x84\x8e" +
|
|
"\xf2\xcd\xb2?\xbc\x8d\xa5\xb3j\xc9\xe2U\xf8\x00\xe3f" +
|
|
"\xd0\xb6\xb3\x86\x8cR>\xd7\xc7A\xb4\xcd\xd1\xaa\xcbd" +
|
|
"|\xba\xd5\x9ay5\xb3\xde\xad\x99\xfeS/\xfa/\xba" +
|
|
"\x922\x06\x82\xb4\x9aj\xa6\xff\xea\x88\xfe\xdf\x1cH\x9d" +
|
|
"\xe3 H\x9f\xa0\x9a\xe9\xbf\xb8\xa3\xff\x8a,\xb5\xbd\x08" +
|
|
"\x82\xd4\x16y\x01\xf3Q\xaaz\x01\xf3~H\xd8\x9a\xf7" +
|
|
"C\xf90\x16*Oc\xaae\xd1\x8eH\xcd\xe5\xb6\x9c" +
|
|
"\xda\xbd\x16\xd1\xe5\xbc\x17M\xfb}%\xf8\xeb\x9f\xff\x9b" +
|
|
"\xa6\xa0\x7f\xb6\xfeO\x00\x00\x00\xff\xff\xb4\x0bQ\xfc"
|
|
|
|
func init() {
|
|
schemas.Register(schema_db8274f9144abc7e,
|
|
0x82c325a07ad22a65,
|
|
0x839445a59fb01686,
|
|
0x83ced0145b2f114b,
|
|
0x84cb9536a2cf6d3c,
|
|
0x85c8cea1ab1894f3,
|
|
0x8635c6b4f45bf5cd,
|
|
0x904e297b87fbecea,
|
|
0x9496331ab9cd463f,
|
|
0x958096448eb3373e,
|
|
0x96b74375ce9b0ef6,
|
|
0x97b3c5c260257622,
|
|
0x9b87b390babc2ccf,
|
|
0xa29a916d4ebdd894,
|
|
0xa353a3556df74984,
|
|
0xa766b24d4fe5da35,
|
|
0xab6d5210c1f26687,
|
|
0xb046e578094b1ead,
|
|
0xb177ca2526a3ca76,
|
|
0xb48edfbdaa25db04,
|
|
0xb4bf9861fe035d04,
|
|
0xb5f39f082b9ac18a,
|
|
0xb70431c0dc014915,
|
|
0xc082ef6e0d42ed1d,
|
|
0xc5d6e311876a3604,
|
|
0xc793e50592935b4a,
|
|
0xcbd96442ae3bb01a,
|
|
0xd4d18de97bb12de3,
|
|
0xdb58ff694ba05cf9,
|
|
0xdbaa9d03d52b62dc,
|
|
0xdc3ed6801961e502,
|
|
0xe3e37d096a5b564e,
|
|
0xe5ceae5d6897d7be,
|
|
0xe6646dec8feaa6ee,
|
|
0xea50d822450d1f17,
|
|
0xea58385c65416035,
|
|
0xf24ec4ab5891b676,
|
|
0xf2c122394f447e8e,
|
|
0xf2c68e2547ec3866,
|
|
0xf41a0f001ad49e46,
|
|
0xf548cef9dea2a4a1,
|
|
0xf5f383d2785edb86,
|
|
0xf71695ec7fe85497,
|
|
0xf9cb7f4431a307d0,
|
|
0xfc5edf80e39c0796,
|
|
0xfeac5c8f4899ef7c)
|
|
}
|