mirror of
https://github.com/cloudflare/cloudflared.git
synced 2025-05-11 09:46:35 +00:00
d68ad89159
This commit adds the tunnel details to RPC register connection response so we can have access to some of the details associacted to the tunnel that only the edge knows. Currently this is limited to knowing if the tunnel is remotely managed or not. In the future we could extend this with more information.
4810 lines
179 KiB
Go
4810 lines
179 KiB
Go
// Code generated by capnpc-go. DO NOT EDIT.
|
|
|
|
package tunnelrpc
|
|
|
|
import (
|
|
context "golang.org/x/net/context"
|
|
strconv "strconv"
|
|
capnp "zombiezen.com/go/capnproto2"
|
|
text "zombiezen.com/go/capnproto2/encoding/text"
|
|
schemas "zombiezen.com/go/capnproto2/schemas"
|
|
server "zombiezen.com/go/capnproto2/server"
|
|
)
|
|
|
|
type Authentication struct{ capnp.Struct }
|
|
|
|
// Authentication_TypeID is the unique identifier for the type Authentication.
|
|
const Authentication_TypeID = 0xc082ef6e0d42ed1d
|
|
|
|
func NewAuthentication(s *capnp.Segment) (Authentication, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return Authentication{st}, err
|
|
}
|
|
|
|
func NewRootAuthentication(s *capnp.Segment) (Authentication, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return Authentication{st}, err
|
|
}
|
|
|
|
func ReadRootAuthentication(msg *capnp.Message) (Authentication, error) {
|
|
root, err := msg.RootPtr()
|
|
return Authentication{root.Struct()}, err
|
|
}
|
|
|
|
func (s Authentication) String() string {
|
|
str, _ := text.Marshal(0xc082ef6e0d42ed1d, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s Authentication) Key() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s Authentication) HasKey() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s Authentication) KeyBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s Authentication) SetKey(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s Authentication) Email() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s Authentication) HasEmail() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s Authentication) EmailBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s Authentication) SetEmail(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s Authentication) OriginCAKey() (string, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s Authentication) HasOriginCAKey() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s Authentication) OriginCAKeyBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s Authentication) SetOriginCAKey(v string) error {
|
|
return s.Struct.SetText(2, v)
|
|
}
|
|
|
|
// Authentication_List is a list of Authentication.
|
|
type Authentication_List struct{ capnp.List }
|
|
|
|
// NewAuthentication creates a new list of Authentication.
|
|
func NewAuthentication_List(s *capnp.Segment, sz int32) (Authentication_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
|
|
return Authentication_List{l}, err
|
|
}
|
|
|
|
func (s Authentication_List) At(i int) Authentication { return Authentication{s.List.Struct(i)} }
|
|
|
|
func (s Authentication_List) Set(i int, v Authentication) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
func (s Authentication_List) String() string {
|
|
str, _ := text.MarshalList(0xc082ef6e0d42ed1d, s.List)
|
|
return str
|
|
}
|
|
|
|
// Authentication_Promise is a wrapper for a Authentication promised by a client call.
|
|
type Authentication_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p Authentication_Promise) Struct() (Authentication, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return Authentication{s}, err
|
|
}
|
|
|
|
type TunnelRegistration struct{ capnp.Struct }
|
|
|
|
// TunnelRegistration_TypeID is the unique identifier for the type TunnelRegistration.
|
|
const TunnelRegistration_TypeID = 0xf41a0f001ad49e46
|
|
|
|
func NewTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 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/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/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/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/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/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/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/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "registerTunnel",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 3}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_registerTunnel_Params{Struct: s}) }
|
|
}
|
|
return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) GetServerInfo(ctx context.Context, params func(TunnelServer_getServerInfo_Params) error, opts ...capnp.CallOption) TunnelServer_getServerInfo_Results_Promise {
|
|
if c.Client == nil {
|
|
return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "getServerInfo",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_getServerInfo_Params{Struct: s}) }
|
|
}
|
|
return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) UnregisterTunnel(ctx context.Context, params func(TunnelServer_unregisterTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_unregisterTunnel_Results_Promise {
|
|
if c.Client == nil {
|
|
return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 2,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "unregisterTunnel",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 0}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_unregisterTunnel_Params{Struct: s}) }
|
|
}
|
|
return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) 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/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/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "authenticate",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 3}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_authenticate_Params{Struct: s}) }
|
|
}
|
|
return TunnelServer_authenticate_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) ReconnectTunnel(ctx context.Context, params func(TunnelServer_reconnectTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_reconnectTunnel_Results_Promise {
|
|
if c.Client == nil {
|
|
return TunnelServer_reconnectTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 5,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "reconnectTunnel",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 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/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/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/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/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "registerTunnel",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_registerTunnel{c, opts, TunnelServer_registerTunnel_Params{Struct: p}, TunnelServer_registerTunnel_Results{Struct: r}}
|
|
return s.RegisterTunnel(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "getServerInfo",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_getServerInfo{c, opts, TunnelServer_getServerInfo_Params{Struct: p}, TunnelServer_getServerInfo_Results{Struct: r}}
|
|
return s.GetServerInfo(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 2,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "unregisterTunnel",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_unregisterTunnel{c, opts, TunnelServer_unregisterTunnel_Params{Struct: p}, TunnelServer_unregisterTunnel_Results{Struct: r}}
|
|
return s.UnregisterTunnel(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 3,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "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/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "authenticate",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_authenticate{c, opts, TunnelServer_authenticate_Params{Struct: p}, TunnelServer_authenticate_Results{Struct: r}}
|
|
return s.Authenticate(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 5,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "reconnectTunnel",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_reconnectTunnel{c, opts, TunnelServer_reconnectTunnel_Params{Struct: p}, TunnelServer_reconnectTunnel_Results{Struct: r}}
|
|
return s.ReconnectTunnel(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf71695ec7fe85497,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/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/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/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: 1})
|
|
return RegisterUdpSessionResponse{st}, err
|
|
}
|
|
|
|
func NewRootRegisterUdpSessionResponse(s *capnp.Segment) (RegisterUdpSessionResponse, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
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)
|
|
}
|
|
|
|
// 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: 1}, 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/tunnelrpc.capnp:SessionManager",
|
|
MethodName: "registerUdpSession",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 16, PointerCount: 2}
|
|
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/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/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/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: 2})
|
|
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: 2})
|
|
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))
|
|
}
|
|
|
|
// 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: 2}, 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/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/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/tunnelrpc.capnp:SessionManager",
|
|
MethodName: "registerUdpSession",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 16, PointerCount: 2}
|
|
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/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/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/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/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/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\x1c\xd5u\xbfwfW#\x19\xad" +
|
|
"G\xc3,\x96\xb5\xc7B\x8d\x8e]j'\x06d\xd7)" +
|
|
"u\xd3H2\xb2\x83\x84?4\xbbV\x0e1&\x87\xd1" +
|
|
"\xee\x934\xea\xee\xcc23+l\x07\xe2\x0fl\x0c\x1c" +
|
|
"B0\xb1\xf9pBc\x9b\xd2\x9e\x98$\x85`\x9a\xba" +
|
|
"\x07Z\x9c\x86\x10Cpp\x0e\xa4&\x86\xa6\x89\xe3\xb6" +
|
|
"\xf8\x98R\x0cn\x8e\xdb\x98\xe9\xb93;\x1f\xda]$" +
|
|
"+\xce\x1f\xf9ou\xe7\xbe\xf7\xee\xfb\xbd\xdf\xfdx\xf7" +
|
|
"\xe9\xea;\x1a\xba\xb8\x8e\xf8F\x11@9\x10\xafs\xd8" +
|
|
"\xbc\x9fl\xd83\xe7\x9f\xb7\x80\x92Bt\xbe\xf8l_" +
|
|
"\xf2\x9c\xbd\xe58\xc4y\x01`\xe1\xe3\xc2\x06\x94\x0f\x0a" +
|
|
"\x02\x80\xfc\x8c\xf0\x1f\x80\xce\x9d3\x9e\xfc\xfa\xe3Kw" +
|
|
"\xde\x01R\x8a\x0f\x95\x01\x17>R\xdf\x87\xf2\xb7\xeaI" +
|
|
"\xf3\x1b\xf5\xdb\xe5\x86\x06\x01\xc0\xb9^\xba\xea\xc6\xe4\xab" +
|
|
"GH;:u\x8c\xa6~\xaf~\x1e\xcaHj\xf2\xf9" +
|
|
"z\x9a\xfaS\x85\x1f\xef\xfb\xe4\xae\x97\xb7\x82\x94\xe2\xc6" +
|
|
"M\xfdv\xc3\x06\x94\xcf\xbb\x9a\xe7\x1aV\x01:\xef\xef" +
|
|
"\x9c\xf9\xc4\xde#?\xdc\x06\xd2\x15\x08eK\xa5i?" +
|
|
"C@y\xce\xb4\xbf\x05t^9{\xe3\x07\x07~\xb0" +
|
|
"\xe8N\x90\xe6\x92\x02\x92\xc2\x0b\xd3\xda9@\xf9\xadi" +
|
|
"\x9d\x80\xce\xa9\xd3\xff\xb7\xfd\x0bsW\xde\x0f\xca\\\xe4" +
|
|
"\x00\xe2\x1ci\x9c\x9f\x96\"\x8d\xcb.!k:\x97\xbd" +
|
|
"r0\xb5\xf0\xc1\x9d\x15\xa6\xbb\x8ag/\x99\x87r\xbc" +
|
|
"\x91\x0c\xc2\xc6[\x01\x9dO\xff\xc9\xd3\xf7\xf5<\xb8i" +
|
|
"\x17HW\x05\xeb\xb1\xc654\xdb\xe6FZ\xef\x7f\xa6" +
|
|
"\x7f\xf5H\xe9\xda\xef>X6\xc8\x9deo\xe3<R" +
|
|
"8\xe8\xce\xd0>6\xe7\xe6\xef\xbd\xf0\xf4C\xa0\xccG" +
|
|
"t\xde\x1c\xfc\xf8\xeb\xfc\xa3\xfb\x8f\xc3\x00\x0ad\xdf\xc2" +
|
|
"\x96\xc4>\xda\xdd\xdc\x04\xe9\xfe\xf8\x13\xcf\xfe\xc3\xfdO" +
|
|
"o\xff*(W \x02\xb8h~)\xf1\xbf\xa4\xb07" +
|
|
"A\xab\xed<\xf6\xdc\xca\xc2\x8e\xdd\xfb<|\xdc\xef\x87" +
|
|
"\x13\x1c\x071gk\xef\xaf\x0b\x03\x8fe\x1e+#\x17" +
|
|
"\xa7O\xcf%\xce \xe0\xc2\xa3\x896\x04t\x16\xfd\xec" +
|
|
"\xe4\xaa\x15\xdf\x19\xfa\x9b\xc8\xd8w\xa6o\xa0\xb1\xdb\x87" +
|
|
"\xce\x1cjJ\x17\x9e\xa8@\xc4\xdd\xec\xdb\xd3\xf7\xa3\x8c" +
|
|
"\xa2{\x98\xd3\xc9\x84o]~}\xc3\xba\x93\xcb\x9e\x04" +
|
|
"i\xbe?M\xab\x98\xa6i\xc6^z\xec\x0f\xe7\xbct" +
|
|
"\xebS\xa0\\\x85\x01X-\xf4\x0d\xe5E\"\xed/v" +
|
|
"|\xce\xfe\xe7~~\xdf\x81*\x8e\xed\x107\xa0\xfc\xb8" +
|
|
"\xbb\xca^\xf13\xf2Q\xfa\xe5\xc4n\xe2?T\x1f\xfe" +
|
|
"\xa7\x03\x95\xfcu1>(\x0e\xa2\xfc\x8a\xe8\" \xba" +
|
|
"\xfb\xbb\xe7\xd0\xee\x8f\xd7\x7f\xfd\xfdgj\xaa\xbf\xd74" +
|
|
"\x88r\\r\x0fV\"\"]\xd6\x8bo>\xdf\x11\xfb" +
|
|
"n\x94i\x8fK\xa7\x08\xea\x83\xaeB\xeb;K\x12\xfa" +
|
|
"\xbb[\x9e\xaf\x00\xc5U\xfc\xdc\xa5}(\x17.\xa5\xd9" +
|
|
"\xb4KI9\xf6\xc9\xd1\xed\xd2\x89\x9f\xbe\xe0\x81\xe2\xed" +
|
|
"<.\x8f\xd2\xce?&\x13j}7~\xe5\x81\xf8\xc9" +
|
|
"\xaf\xbcH\xc6E| Nn\xb5\xb0[6Q\x1e\x90" +
|
|
"\xe9\xa7\"7\xf3\x80N\xea\xc9?\xfb\xf6\x92\xdc\x1b/" +
|
|
"\xd7\xe0\xa8|t\xc6\x19\xf9\xad\x19\xf4\xeb\x8d\x19\x04\xea" +
|
|
"\x89\xf9O}\xe1\xed/\x1d}\xad\xbc\x13w\xedE\xcd" +
|
|
".iz\x9bi\xedsk\xf7\\\xaf97\x1c\xaf\x04" +
|
|
"\xc6\xd5\xd4\x9a\xbf\x83\xf2\xe6f\x9a\xee\xf6f\x9a.`" +
|
|
"h-\xed_4\x8f\xa2|\xd6\xd5~\xcf\x9d\x9b;\xa9" +
|
|
"\xb6l\xfa\xe9\xa7\xdf\x8c\x90\xeal\xf3/\x11b\xce\xca" +
|
|
"\xcf\xde8\xdap\xfb\x89\x13Q\xb3\xdenv\x01>\xef" +
|
|
"\x0e\xfd\xc7\x7fyh\xe4\xa6o\x1f9\x19%\xd2L\x93" +
|
|
"\x88\xf4_\x7f}\xea\xcb\xa7\x0b\xb9\x7fw]\xc6?\x9c" +
|
|
"\x96\x99\x8b\x09\xce\x8e\x99\xe4\xc3\xcdm\x89\xa5\xed\xc7\xfa" +
|
|
"OE\xf1N\xb4,!\x859-4\xf9\xa2\x9b\xbb\xd9" +
|
|
"\xdakn8U\xc5\xb4\xa5-\x8bQ\x1ehq\xb1n" +
|
|
"\xd9\x8e\xb2\x96j\x06p\xc6\xfen\xc7\x0dO|\x7f\xe5" +
|
|
"\x19\xcf\x8b][>\x97Z@\xb6\xdc\xf7\xc5\x9eU\x7f" +
|
|
"\xda~\xe8Lt\x1bJ\x8a\xfcJf)Zi\xe8\x9a" +
|
|
"\xd3\x9f\x99s\xdf\x0f\xce\xd4r\x9em\xa9y(\xefJ" +
|
|
"\x11\\;H\xf9\xdde\x7f\xf9ZJL}P\x01m" +
|
|
"\x1d\xe9>\x93\x1aE\xf9p\xca\x0dh\xa9\x17\x89\xd0{" +
|
|
"\xffj\xdf\xbf\x9e;r\xdd\xd9\xaa=\x1c\x9cE\xdc\x9f" +
|
|
"E\xd3\x1e\x9e%\xc8\x87g]\x01\xe0\xdcy\xfc\xf3\xeb" +
|
|
"~r\xc7\xfbg+\x19\xe6\x1arhV\x1a\xe5\xd7\xdd" +
|
|
"\x11Gg\x11a\x1fZ\xfd\x9f\x1bO\xef\x9a\xf1\xeb\xaa" +
|
|
"\xb9oi\x1dEy[+inn}Q\xbe\xecr" +
|
|
"\xf2\xc4W\x85\xc7:z6\xbe|.rT\xe7[\xfb" +
|
|
"\x08\x9e\x07\x85\xaf\x9d\xd8\xf4\xf3\xcf\xff&\x0a\xcf\xb9\xd6" +
|
|
"_\x12<\x89\xcb\x09\x9e\xdb\xde}\xe4\xba/\xaf\xfd\xe6" +
|
|
"\x87\x11\x82\xcc\xbf|\x0b\x0d\xb5K\xba\xce\xf2f1\x96" +
|
|
"\xbd\xca\xff\x99\xbd2\xab\x16\xf5\xe2\xe2\xee\x92=\xc2t" +
|
|
"[\xcb\xaa6K\xb3N\xabh\xe8\x16\xebGT\x9a\xf8" +
|
|
"\x18@\x0c\x01$u\x14@\xb9\x99G%\xcf\xa1\x84\x98" +
|
|
"$\xa2H\x1a\x09GxTl\x0e%\x8eKR\x84\x95" +
|
|
"ni\x07P\xf2<*\xeb8D>\x89<\x80Tz" +
|
|
"\x00@Y\xc7\xa3\xb2\x95C\xa7\xc8\xcc\x82\xaa3\x1dD" +
|
|
"{\xa9ib#p\xd8\x08\xe8\x98\xcc6\xd7\xab\x83y" +
|
|
"\x10YD,\x8c\xdejc\x028L\x00:#F\xc9" +
|
|
"\xb4\x06t\x1b\xb5|\x9a\x0d\x99\xcc\xc2\x11\xac\x03\x0e\xeb" +
|
|
"\x00'\xda^\x86Y\x96f\xe8+T]\x1df&\x00" +
|
|
"\xed\xac\x9e\x8f\x03\x04\xd9\x0b\xfd<'u\xec\x06N\x9a" +
|
|
"/`\x98i\xd0'\xab\xf4\xb1\xfd\xc0I\xad\x82c\xb2" +
|
|
"a\xcd\xb2\x99\x89\x03\xb9\xa2;7o\xe8]\xe8\x94t" +
|
|
"\xef\x032\xd3\xfb \xd2\xaa]\xd8\x8f\xa1u|\xb5u" +
|
|
"\xd7\xe65\xa6\xdbb\xaf>dT@\xdeW\x0b\xf2\xbe" +
|
|
"2\xe4[#\x90o^\x02\xa0\xdc\xc6\xa3r\x17\x87\x12" +
|
|
"_\xc6|\xdb<\x00e\x13\x8f\xca\xbd\x1c:Yw\x91" +
|
|
"\xde\x1c\x00\x04h\x0e1\xd5.\x99\xcc\"\xd9t\xc0~" +
|
|
"\x1e]\xd0\xa7\x03n\x1cc&\xd9\xee\x1f\x82\xa8\x9a\xd9" +
|
|
"\x91\xe0\xa0&@z\xe9:\xcd\xb25}x\xb5+\xef" +
|
|
"\xec7\xf2Zv=\xed\xaa\xd1\xb5\xb3u1\x00\xa2t" +
|
|
"\xd9\x1a\x00\xe4$i\x09@\xa76\xac\x1b&sr\x9a" +
|
|
"\x955t\x9d\x01\x9f\xb57\x0e\xaayU\xcf\xb2`\xa1" +
|
|
"\xba\xea\x85\xbc\x052\xcc\x1cc\xe6\x95j\x84\xbe\xb3\xfb" +
|
|
"US\xe5\x0b\x96\xd2\x18\xe0\xb8t\x0d\x80\xd2\xc3\xa3\xd2" +
|
|
"\x1f\xc1q\x05\xe1\xb8\x9cG\xe5\x86\x08\x8e\x03\x84c?" +
|
|
"\x8f\xcaZ\x0e\x1d\xc3\xd4\x865\xfdZ\x06\xbc\x19e\xa0" +
|
|
"e\xebj\x81\x11fe<6\x1aE[3t\x0b\x9b" +
|
|
"\xc2\xac\x03\x88M\x11\xa4\x84\xc98y\xa5O)\x9fQ" +
|
|
"\x86>;\xcd\xac\x92\x90\xb7-%\x16\xec$\xb1\x18@" +
|
|
"\xa9\xe7QIr\xd8i2\xab\x94\xb7\xb1),'~" +
|
|
"\x17\xab\xfa\xf0Eh\x98\xaeE\xc3\x05\x00J\x8eG\xa5" +
|
|
"\xc8!\x96\xd1+,\x89D\x03\x1e=\x16\xde\xb2\x1b@" +
|
|
"\xb1yT6q\xe8X\xde\"\xbd\x809\x1f\xd1\xb6\x9c" +
|
|
"e\xf7\x16\xfd\xbf6\xe6,\xbb\xdf0m\x14\x80C\x01" +
|
|
"\x88\xb7\x86\xc5\xba\x87\xc8\xa7zsyv\x9d\xc6\xeb6" +
|
|
"\xc6\x81\xc38L\xe8T\x1e?D\x0al\x9e\xb7\xfb\xbb" +
|
|
"\x99Kd\xf8#\x1e\x95?\x8e\xec\xa6\x83\xe2\xd8\xd5<" +
|
|
"*\x9f\xe2\xd0Q\xb3Y\xa3\xa4\xdb\xab\x81W\x87+8" +
|
|
"\x9fa fM\x16\xd2\xc1_\xb6\xbe\x86[\x1b\xfa\x90" +
|
|
"6\\2U;\x02x\xa9\x98Sm6\xee\x93{\xce" +
|
|
"y\xfe\x02\xce9\xa8+\xa6|\xce~d\xaa8i\xd1" +
|
|
"T\x0bV\x14\x9bt-l\xe8T?\xc1\xa3rM\xed" +
|
|
"\x03\xdcX`\x96\xa5\x0e\xb3\xaa\xf0\x10\xaf\x89\x89\xce\xb2" +
|
|
"\xb4\xeb4\xf3\x92\xcc\x95&\xb3\x84R\xde&+\x1a\x1d" +
|
|
"\xc73\x83\xb85\x9bG\xe5j\x0e\x13\xf8\xa1\xe3\xd91" +
|
|
"\xff\x81\xf0\x8c\xda\x98i\x1a&6\x85I\xb8\x0cI\xb6" +
|
|
"\xbc\x00\x1az\x0f\xb3U-\x8f\xe4\x96A\xa5Z\x01\xdc" +
|
|
"dq%\x84\xcd\x13\xcf\xee$\xef(\x8c;)\xa2w" +
|
|
"\x13\x8f\xca,\x0e\x9daS\xcd\xb2~f\xa2f\xe4V" +
|
|
"\xaa\xba\x91\xe1Y\xb6\x8a\xac\xd3\xa7\xba\xa8\xcb\x0f\xdb\x82" +
|
|
"`\xd4\xc4\xe3MV\x06\xa1<\xbc\xbf\xcd\xb39\x19\xd8" +
|
|
"|{{\x98\x8c\x83c\xde<\x18f\x8b \x1e\xdeM" +
|
|
"\xcer\x17\x8f\xca\xceH^\xd9A\x91\xf3~\x1e\x95\xaf" +
|
|
"q(\xc5bI\x8c\x01H\x8f\x10Kv\xf2\xa8\xec\xe1" +
|
|
"\xc6\xa7l6\xc6t\xbbG\x1b\x06\x81Y\xa1\x94L\xec" +
|
|
"\xd1\x86\x19\xf0\xd6\xc5\xc6\xd6\xfaI\xf00\x06-#\xcf" +
|
|
"l\xd6\xc3\xb2y\x95\\n\x8cy\xdf\xcbd\xf4\x0fu" +
|
|
"\"\xde\xa6\xab\xbc\x87\xf8+\xfaUR\x84\x0e\xed\xa1\xe3" +
|
|
"\x0a,R\xdcL`\xad7\xb9\x17\x0c\xaa8\x10zL" +
|
|
"\x99\x07h\xfdN\x82\x8e\xbbg\x1c\xe7\xfcKB\xaf\xf3" +
|
|
"I1\x7fq\x18\x10\x82\x9a \x06\x1c\xc6\x00;\xb3\xee" +
|
|
"\x84U\xa106\x99U\x9d\x9eY\x1epT\x84\xf9\xf7" +
|
|
"X\xf4/\xff\x92\xb4\x0f8)!8\xbe\xe5\xe8\x8f\x17" +
|
|
"\xaa\x0a\xaa\xd8DQfU\xd1\xd6\x04C\xb7h\xad\x08" +
|
|
"\xff\x17\xd7\xe2\xbf\x19\xf2\xdfOhwo\x89\xd2\xbf\x9c" +
|
|
"\xd0v\xec\x0e\x99.\xc58\x8f\xfe\x8f\xee\x03P\xf6\xf0" +
|
|
"\xa8|\x93\xc3N\xaf\xd6\xc2\xa6\xb0iS\xa6\xacWQ" +
|
|
",7\xa0-\xab\xe6\xc3\xa4\xe7\x98\xac\x98W\xb3l)" +
|
|
"\x96\xab'@\x04\x0e\xd1\xf5\x93B\xd1d\x96\x85\x9a\xa1" +
|
|
"+%5\xaf\xf1\xf6\xfa\xa0\xe2\xd5K\x85~\x93\x8di" +
|
|
"h\x94\xacn\xdbf\x05\xa1h[\x17R\x0f\x87\x00Q" +
|
|
"\x90\x14\xb4\xbc\x0bP\xa4`\xa2\xca\xb1\x8bGey\x04" +
|
|
"\xa0^\xca\x91\xd7\xf1\xa8\xac\x0e\x01R\xbe\x07\xa0\xac\xe6" +
|
|
"Q\xb9\x99C\xb1T\xd2\x82\xa4\xe0\xe4\x8d\xac{\xda " +
|
|
"\xaeT\x0b\x95\xb9\xa1\xd7\xe2\xd2\xac`\xd8,\xbf\xde\xe3" +
|
|
"h.\xdc\xf1\x85\xc6\xe6\x8a \xe9'\xb3\xdf\xa7\xaao" +
|
|
"\xe2\x8b\x16\x81\x03\x15\xb8\xb7\xd7\xc2}Ad\x1f\xbe\xc9" +
|
|
"+\x06\xc3}\x08\x7f\xc1\xd6\xfbV\xb5\xb1\x02%=\x1f" +
|
|
"\xee\xf2f\xbaA\xb8>\xd4\x99j,r}p\xb9\x91" +
|
|
"U\xf3\x95!D\xacL\x86\xd1\xb2\xe5\xc2\xc3Ct\xd1" +
|
|
"U\xc56\x17V\x02\xe6\x1a\x7fby=\xf6\x01d\xd6" +
|
|
"!\x8f\x99\xad\x18b#o\xc6%\x00\x99\xdbH~\x17" +
|
|
"\x86\xf0\xc8\xdb0\x05\x90\xd9D\xf2{1\xb8\x85\xcaw" +
|
|
"\xe3~\x80\xcc\xbd$~\x98\xd4c\xbc\xeb\xbd\xf2.w" +
|
|
"\xfa\x9d$\xdfC\xf2x,\x89q\x00\xf9Q\x9c\x07\x90" +
|
|
"y\x98\xe4\x07H^\xc7%\xb1\x0e@~\x0aG\x012" +
|
|
"O\x92\xfcY\x92\x0b\xf1$]\xc4\xe5\x83h\x02d\xfe" +
|
|
"\x9e\xe4\xdf'y\xfd\xcc$\xd6\x03\xc8\x87\\\xf9\xf3$" +
|
|
"\xff\x11\xc9\x1bZ\x92\xd8\x00 \x1f\xc6-\x00\x99\x1f\x92" +
|
|
"\xfc5\x92O\xc3$N\x03\x90\x8f\xe2n\x80\xcck$" +
|
|
"\xff7\x92_R\x97\xc4K\x00\xe4\xb7\\{\x8e\x91\xfc" +
|
|
"W$o\x8c%\xb1\x11@\xfe\x05\xee\x03\xc8\xfc\x8a\xe4" +
|
|
"\xffM\xf2\x84\x90\xc4\x04\x80\xfc\x8e\xbb\xaf\xd3$\xaf\xe7" +
|
|
"*.\x81>\x8d+nz\xbca\x05<a\xe5p\x84" +
|
|
"\x9e\x8f\xf5\x1b\"\xdd\xe6P\x0c\xfb\xcb\x80(\x02:E" +
|
|
"\xc3\xc8\xaf\x1c\xef\x1e\xa2\xad\x0e[\xfe\xad\xb2)\xec\xaf" +
|
|
"\x01\x920\xa8\xd3@4\xf4\xde\\\x10\xb3*\x03\xa4o" +
|
|
"\x89fu\x97l\xa3T\x846\xe2b.\x08\x16fI" +
|
|
"_f\x1a\x85\xd5\xc8\xcc\x82\xa6\xab\xf9I\x02g\x03p" +
|
|
"\xd8\x00\xe5H\xe5\xcf=q\x14\xfd\xe8;r\xc0h\xae" +
|
|
"\x92\xd1m\xc5\xc5\xab\xd5\xe1\x8ak\xc7\xbc0\xbb\x06\xae" +
|
|
"=\x7fA\x98^E=\x12'\xdb\xc6\xd4|\xa9\xba\xa2" +
|
|
"\xae\x9bb\xe9\x97\xee\xf4J\xc7\xc9n\x16~\x9b\xac\"" +
|
|
"~\xd5(\x84\x06\xaaK\x894\xb3\xda\x82~Qd\xc3" +
|
|
"\xfb\xc3k\x83\xbf\xdfE\xed\x91kV^\xb5\x99ew" +
|
|
"\x17\xb1\x98\xd7X\xee\xb3\xcc\x14\xa3\xd5E\xcd\xe2)6" +
|
|
"\xd9\x8db|E\x86\x91\xc7\x00\xda8W\xde\xf0\x05\xe3" +
|
|
"9\xccl\xefW\xaf>dP\xc9$D\xeb\xc4\xa9\x8d" +
|
|
"N3K\xbc\x90\xb3\x08\xfb\x9b\x93\xd7\xb9S\x89\xd6i" +
|
|
"\xd6\xe6ra\xa2[c\x8d\xf9j\xd4\xa1\xfe%(\xd2" +
|
|
"! r\xaf\xe5Q\x19\x89\x90\x9b\xf5\xd5\xe8\x10\xa4\xc3" +
|
|
"\xd6\xa0\xc4s\xe5\xde \xa5\xdf\"\x8f\xcam\x1c\x8aj" +
|
|
"\xc9\x1e\xc1\xa6\xf0\xcdh\x1c\x08\xe3\xdbW\xc4\xf5^=" +
|
|
"\xc7\x00\xd7\xf9\xee\x1aI\xca\xc1c\xc6o\x05\xe3G\x96" +
|
|
"\xdf\x16Lz\x80AC\xbfb\xe5\x8f\xecRtz\x8b" +
|
|
"\x12og\xba\x05\xb1\xffV\x82~3\\zj\x03p" +
|
|
"\xd27\x04\x0c\x1f\x00\xd0\xef\xf7K\x8f\x9a\xc0I\xbb\x04" +
|
|
"\xe4\x82\xe7,\xf4\x9f\xad\xa4\xbb\xef\x01N\xda& \x1f" +
|
|
"\xbcF\xa1\xdf \xeeX?\x0d\x81\x93n\x170\x16<" +
|
|
"\x03\xa2\xdf^\x96n\x19\x05N\xd2\x04\x8c\x07\x0f]\xe8" +
|
|
"\xbf{H7m\x01N\x1a\x08\xdb\xa0\xd0\xe9\xed\xa3\x0b" +
|
|
"\x1d\x9f\xf3\xd0\xe6\xb2~|S\xd4\xd3\x02\xe8B\xc7\xbf" +
|
|
"\x94\xf1\x1fu+s\xb5\xfc\xbe\x1e\x88Y\xd5f]T" +
|
|
"({\x01\x0e\xcb\x11\x0e\xbaP\x89a\xa4\xbb\x0ep\xb1" +
|
|
"]\x91*?\x99b!\xea\x8f\xff-c._\xcbj" +
|
|
"Z'\xe8\x0fG\xe6\xa5\x8a\xbc\x91Ge&7I\xc1" +
|
|
"]3tz\x06\xfb\xe4\x17i0\xcd\xff\x07\xc1\xfcG" +
|
|
")\\\xff\x88G\xe5X\xc4\xad_'\xe1\xab<*o" +
|
|
"F\xca\xd17\xc8\xd7\x8f\xf1\xa8|\x10\xb6\xfc\xdf\xbb\x07" +
|
|
"@\xf9\x80\xc7t\xa4\xd2\x92\xce\x93\xe2o\xa8\x1eq\xeb" +
|
|
",\xf4\xea\xac8>\x00\x90\xa9\xa7:%\xe9\xd6Y1" +
|
|
"\xaf\xce\x92p\x10 \xd3D\xf2Y\xd1:\xab\x05\xd7\x00" +
|
|
"df\x92|6\x8e\xbfh\x0b%3,\x7f\xf3\xc6\xf0" +
|
|
"rM\xaf\x99\xbc\xfd7\x08\xb4\x97\xa9Z\xbed2\xa8" +
|
|
"\xbc\x82\xf4\xf6D\xca\x19\xefq\xc2\xebCf\x88\x849" +
|
|
"\xb4\x82\x1e\xe5\x14Z\x1c\x13e\xb2\xbcQ\xca\x0d\xe5U" +
|
|
"\x93\xe52\xcc\x14\xbc\x80\xd0\xcf\xc7\x95z\x8c\xfc\xb3\x00" +
|
|
"@\xf8\xa8\x1b!\xfb\x84\x99q\xa9i\x1ahV\\5" +
|
|
"\x16\x84W\x8d\xe0\xa6\xb1&\xbc\xe1I\\W\xf9\x8a7" +
|
|
"\x18^\x8e\xda\xb2j\xc9bU\x98\x00\xcf\xcc\xa0\xcde" +
|
|
"\x8d\x18\xa5|.\xcd@\xb0\xcd\xf5U\xb7\xba\xd8d\xd1" +
|
|
"W\xf4#a\xa3\x1b\x09\xfd\x97I\xf4\x1f %e7" +
|
|
"p\xd2\x0a\x8a\x84\xfe#\x19\xfa/\xe4R\xf7~\xe0\xa4" +
|
|
"?\xa7H\xe8\xbf\x0f\xa3\xff\xe8)u\xbc\x04\x9c\xd4\x11" +
|
|
"y\xbb\xf1\xf1\xa9z\xbb\xf1>\xb8\xfe@\x1f\xca\x09\x95" +
|
|
"\xab\xcc\xa8\x14\xa1\xa2\x8d\x88\x8b\xe8\xecx\x095r\x9c" +
|
|
"Sz\xf0\xb8\xe0w\x82\xe0\xffS*bN\xc3\xc5v" +
|
|
"\xd0\xfc\xd4\xf8\xff\x01\x00\x00\xff\xff|\xba\xdf\xe8"
|
|
|
|
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)
|
|
}
|