cloudflared-mirror/tunnelrpc/tunnelrpc.capnp.go

4810 lines
179 KiB
Go
Raw Normal View History

// Code generated by capnpc-go. DO NOT EDIT.
package tunnelrpc
import (
context "golang.org/x/net/context"
strconv "strconv"
capnp "zombiezen.com/go/capnproto2"
text "zombiezen.com/go/capnproto2/encoding/text"
schemas "zombiezen.com/go/capnproto2/schemas"
server "zombiezen.com/go/capnproto2/server"
)
type Authentication struct{ capnp.Struct }
// Authentication_TypeID is the unique identifier for the type Authentication.
const Authentication_TypeID = 0xc082ef6e0d42ed1d
func NewAuthentication(s *capnp.Segment) (Authentication, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return Authentication{st}, err
}
func NewRootAuthentication(s *capnp.Segment) (Authentication, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return Authentication{st}, err
}
func ReadRootAuthentication(msg *capnp.Message) (Authentication, error) {
root, err := msg.RootPtr()
return Authentication{root.Struct()}, err
}
func (s Authentication) String() string {
str, _ := text.Marshal(0xc082ef6e0d42ed1d, s.Struct)
return str
}
func (s Authentication) Key() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Authentication) HasKey() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Authentication) KeyBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Authentication) SetKey(v string) error {
return s.Struct.SetText(0, v)
}
func (s Authentication) Email() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s Authentication) HasEmail() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s Authentication) EmailBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s Authentication) SetEmail(v string) error {
return s.Struct.SetText(1, v)
}
func (s Authentication) OriginCAKey() (string, error) {
p, err := s.Struct.Ptr(2)
return p.Text(), err
}
func (s Authentication) HasOriginCAKey() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s Authentication) OriginCAKeyBytes() ([]byte, error) {
p, err := s.Struct.Ptr(2)
return p.TextBytes(), err
}
func (s Authentication) SetOriginCAKey(v string) error {
return s.Struct.SetText(2, v)
}
// Authentication_List is a list of Authentication.
type Authentication_List struct{ capnp.List }
// NewAuthentication creates a new list of Authentication.
func NewAuthentication_List(s *capnp.Segment, sz int32) (Authentication_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
return Authentication_List{l}, err
}
func (s Authentication_List) At(i int) Authentication { return Authentication{s.List.Struct(i)} }
func (s Authentication_List) Set(i int, v Authentication) error { return s.List.SetStruct(i, v.Struct) }
func (s Authentication_List) String() string {
str, _ := text.MarshalList(0xc082ef6e0d42ed1d, s.List)
return str
}
// Authentication_Promise is a wrapper for a Authentication promised by a client call.
type Authentication_Promise struct{ *capnp.Pipeline }
func (p Authentication_Promise) Struct() (Authentication, error) {
s, err := p.Pipeline.Struct()
return Authentication{s}, err
}
type TunnelRegistration struct{ capnp.Struct }
// TunnelRegistration_TypeID is the unique identifier for the type TunnelRegistration.
const TunnelRegistration_TypeID = 0xf41a0f001ad49e46
func NewTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 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)} }
2019-03-18 23:14:47 +00:00
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 {
2019-03-18 23:14:47 +00:00
if c.Client == nil {
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
2019-03-18 23:14:47 +00:00
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 3,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "obsoleteDeclarativeTunnelConnect",
2019-03-18 23:14:47 +00:00
},
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})
}
2019-03-18 23:14:47 +00:00
}
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
2019-03-18 23:14:47 +00:00
}
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
2019-03-18 23:14:47 +00:00
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},
})
2019-03-18 23:14:47 +00:00
methods = append(methods, server.Method{
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 3,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "obsoleteDeclarativeTunnelConnect",
2019-03-18 23:14:47 +00:00
},
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)
2019-03-18 23:14:47 +00:00
},
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
2019-03-18 23:14:47 +00:00
})
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 {
2019-03-18 23:14:47 +00:00
Ctx context.Context
Options capnp.CallOptions
Params TunnelServer_obsoleteDeclarativeTunnelConnect_Params
Results TunnelServer_obsoleteDeclarativeTunnelConnect_Results
2019-03-18 23:14:47 +00:00
}
// 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 }
2019-03-18 23:14:47 +00:00
// TunnelServer_obsoleteDeclarativeTunnelConnect_Params_TypeID is the unique identifier for the type TunnelServer_obsoleteDeclarativeTunnelConnect_Params.
const TunnelServer_obsoleteDeclarativeTunnelConnect_Params_TypeID = 0xa766b24d4fe5da35
2019-03-18 23:14:47 +00:00
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
2019-03-18 23:14:47 +00:00
}
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
2019-03-18 23:14:47 +00:00
}
func ReadRootTunnelServer_obsoleteDeclarativeTunnelConnect_Params(msg *capnp.Message) (TunnelServer_obsoleteDeclarativeTunnelConnect_Params, error) {
2019-03-18 23:14:47 +00:00
root, err := msg.RootPtr()
return TunnelServer_obsoleteDeclarativeTunnelConnect_Params{root.Struct()}, err
2019-03-18 23:14:47 +00:00
}
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Params) String() string {
str, _ := text.Marshal(0xa766b24d4fe5da35, s.Struct)
2019-03-18 23:14:47 +00:00
return str
}
// TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List is a list of TunnelServer_obsoleteDeclarativeTunnelConnect_Params.
type TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List struct{ capnp.List }
2019-03-18 23:14:47 +00:00
// 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
2019-03-18 23:14:47 +00:00
}
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List) At(i int) TunnelServer_obsoleteDeclarativeTunnelConnect_Params {
return TunnelServer_obsoleteDeclarativeTunnelConnect_Params{s.List.Struct(i)}
2019-03-18 23:14:47 +00:00
}
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Params_List) Set(i int, v TunnelServer_obsoleteDeclarativeTunnelConnect_Params) error {
2019-03-18 23:14:47 +00:00
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 }
2019-03-18 23:14:47 +00:00
func (p TunnelServer_obsoleteDeclarativeTunnelConnect_Params_Promise) Struct() (TunnelServer_obsoleteDeclarativeTunnelConnect_Params, error) {
2019-03-18 23:14:47 +00:00
s, err := p.Pipeline.Struct()
return TunnelServer_obsoleteDeclarativeTunnelConnect_Params{s}, err
2019-03-18 23:14:47 +00:00
}
type TunnelServer_obsoleteDeclarativeTunnelConnect_Results struct{ capnp.Struct }
2019-03-18 23:14:47 +00:00
// TunnelServer_obsoleteDeclarativeTunnelConnect_Results_TypeID is the unique identifier for the type TunnelServer_obsoleteDeclarativeTunnelConnect_Results.
const TunnelServer_obsoleteDeclarativeTunnelConnect_Results_TypeID = 0xfeac5c8f4899ef7c
2019-03-18 23:14:47 +00:00
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
2019-03-18 23:14:47 +00:00
}
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
2019-03-18 23:14:47 +00:00
}
func ReadRootTunnelServer_obsoleteDeclarativeTunnelConnect_Results(msg *capnp.Message) (TunnelServer_obsoleteDeclarativeTunnelConnect_Results, error) {
2019-03-18 23:14:47 +00:00
root, err := msg.RootPtr()
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results{root.Struct()}, err
2019-03-18 23:14:47 +00:00
}
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Results) String() string {
str, _ := text.Marshal(0xfeac5c8f4899ef7c, s.Struct)
2019-03-18 23:14:47 +00:00
return str
}
// TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List is a list of TunnelServer_obsoleteDeclarativeTunnelConnect_Results.
type TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List struct{ capnp.List }
2019-03-18 23:14:47 +00:00
// 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
2019-03-18 23:14:47 +00:00
}
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List) At(i int) TunnelServer_obsoleteDeclarativeTunnelConnect_Results {
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results{s.List.Struct(i)}
2019-03-18 23:14:47 +00:00
}
func (s TunnelServer_obsoleteDeclarativeTunnelConnect_Results_List) Set(i int, v TunnelServer_obsoleteDeclarativeTunnelConnect_Results) error {
2019-03-18 23:14:47 +00:00
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 }
2019-03-18 23:14:47 +00:00
func (p TunnelServer_obsoleteDeclarativeTunnelConnect_Results_Promise) Struct() (TunnelServer_obsoleteDeclarativeTunnelConnect_Results, error) {
2019-03-18 23:14:47 +00:00
s, err := p.Pipeline.Struct()
return TunnelServer_obsoleteDeclarativeTunnelConnect_Results{s}, err
2019-03-18 23:14:47 +00:00
}
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,
2019-03-18 23:14:47 +00:00
0xa766b24d4fe5da35,
0xab6d5210c1f26687,
0xb046e578094b1ead,
0xb177ca2526a3ca76,
0xb48edfbdaa25db04,
0xb4bf9861fe035d04,
0xb5f39f082b9ac18a,
0xb70431c0dc014915,
0xc082ef6e0d42ed1d,
0xc5d6e311876a3604,
0xc793e50592935b4a,
0xcbd96442ae3bb01a,
0xd4d18de97bb12de3,
0xdb58ff694ba05cf9,
0xdbaa9d03d52b62dc,
0xdc3ed6801961e502,
0xe3e37d096a5b564e,
0xe5ceae5d6897d7be,
0xe6646dec8feaa6ee,
0xea50d822450d1f17,
0xea58385c65416035,
0xf24ec4ab5891b676,
0xf2c122394f447e8e,
0xf2c68e2547ec3866,
2019-03-18 23:14:47 +00:00
0xf41a0f001ad49e46,
0xf548cef9dea2a4a1,
0xf5f383d2785edb86,
0xf71695ec7fe85497,
0xf9cb7f4431a307d0,
0xfc5edf80e39c0796,
0xfeac5c8f4899ef7c)
}