3184 lines
107 KiB
Go
3184 lines
107 KiB
Go
// Code generated by capnpc-go. DO NOT EDIT.
|
|
|
|
package tunnelrpc
|
|
|
|
import (
|
|
context "golang.org/x/net/context"
|
|
strconv "strconv"
|
|
capnp "zombiezen.com/go/capnproto2"
|
|
text "zombiezen.com/go/capnproto2/encoding/text"
|
|
schemas "zombiezen.com/go/capnproto2/schemas"
|
|
server "zombiezen.com/go/capnproto2/server"
|
|
)
|
|
|
|
type Authentication struct{ capnp.Struct }
|
|
|
|
// Authentication_TypeID is the unique identifier for the type Authentication.
|
|
const Authentication_TypeID = 0xc082ef6e0d42ed1d
|
|
|
|
func NewAuthentication(s *capnp.Segment) (Authentication, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return Authentication{st}, err
|
|
}
|
|
|
|
func NewRootAuthentication(s *capnp.Segment) (Authentication, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return Authentication{st}, err
|
|
}
|
|
|
|
func ReadRootAuthentication(msg *capnp.Message) (Authentication, error) {
|
|
root, err := msg.RootPtr()
|
|
return Authentication{root.Struct()}, err
|
|
}
|
|
|
|
func (s Authentication) String() string {
|
|
str, _ := text.Marshal(0xc082ef6e0d42ed1d, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s Authentication) Key() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s Authentication) HasKey() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s Authentication) KeyBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s Authentication) SetKey(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s Authentication) Email() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s Authentication) HasEmail() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s Authentication) EmailBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s Authentication) SetEmail(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s Authentication) OriginCAKey() (string, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s Authentication) HasOriginCAKey() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s Authentication) OriginCAKeyBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s Authentication) SetOriginCAKey(v string) error {
|
|
return s.Struct.SetText(2, v)
|
|
}
|
|
|
|
// Authentication_List is a list of Authentication.
|
|
type Authentication_List struct{ capnp.List }
|
|
|
|
// NewAuthentication creates a new list of Authentication.
|
|
func NewAuthentication_List(s *capnp.Segment, sz int32) (Authentication_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
|
|
return Authentication_List{l}, err
|
|
}
|
|
|
|
func (s Authentication_List) At(i int) Authentication { return Authentication{s.List.Struct(i)} }
|
|
|
|
func (s Authentication_List) Set(i int, v Authentication) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
// Authentication_Promise is a wrapper for a Authentication promised by a client call.
|
|
type Authentication_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p Authentication_Promise) Struct() (Authentication, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return Authentication{s}, err
|
|
}
|
|
|
|
type TunnelRegistration struct{ capnp.Struct }
|
|
|
|
// TunnelRegistration_TypeID is the unique identifier for the type TunnelRegistration.
|
|
const TunnelRegistration_TypeID = 0xf41a0f001ad49e46
|
|
|
|
func NewTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
|
|
return TunnelRegistration{st}, err
|
|
}
|
|
|
|
func NewRootTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
|
|
return TunnelRegistration{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelRegistration(msg *capnp.Message) (TunnelRegistration, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelRegistration{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelRegistration) String() string {
|
|
str, _ := text.Marshal(0xf41a0f001ad49e46, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelRegistration) Err() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) HasErr() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelRegistration) ErrBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) SetErr(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s TunnelRegistration) Url() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) HasUrl() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelRegistration) UrlBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) SetUrl(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s TunnelRegistration) LogLines() (capnp.TextList, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return capnp.TextList{List: p.List()}, err
|
|
}
|
|
|
|
func (s TunnelRegistration) HasLogLines() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelRegistration) SetLogLines(v capnp.TextList) error {
|
|
return s.Struct.SetPtr(2, v.List.ToPtr())
|
|
}
|
|
|
|
// NewLogLines sets the logLines field to a newly
|
|
// allocated capnp.TextList, preferring placement in s's segment.
|
|
func (s TunnelRegistration) NewLogLines(n int32) (capnp.TextList, error) {
|
|
l, err := capnp.NewTextList(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return capnp.TextList{}, err
|
|
}
|
|
err = s.Struct.SetPtr(2, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
func (s TunnelRegistration) PermanentFailure() bool {
|
|
return s.Struct.Bit(0)
|
|
}
|
|
|
|
func (s TunnelRegistration) SetPermanentFailure(v bool) {
|
|
s.Struct.SetBit(0, v)
|
|
}
|
|
|
|
func (s TunnelRegistration) TunnelID() (string, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) HasTunnelID() bool {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelRegistration) TunnelIDBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s TunnelRegistration) SetTunnelID(v string) error {
|
|
return s.Struct.SetText(3, v)
|
|
}
|
|
|
|
// TunnelRegistration_List is a list of TunnelRegistration.
|
|
type TunnelRegistration_List struct{ capnp.List }
|
|
|
|
// NewTunnelRegistration creates a new list of TunnelRegistration.
|
|
func NewTunnelRegistration_List(s *capnp.Segment, sz int32) (TunnelRegistration_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}, sz)
|
|
return TunnelRegistration_List{l}, err
|
|
}
|
|
|
|
func (s TunnelRegistration_List) At(i int) TunnelRegistration {
|
|
return TunnelRegistration{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelRegistration_List) Set(i int, v TunnelRegistration) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelRegistration_Promise is a wrapper for a TunnelRegistration promised by a client call.
|
|
type TunnelRegistration_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelRegistration_Promise) Struct() (TunnelRegistration, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelRegistration{s}, err
|
|
}
|
|
|
|
type RegistrationOptions struct{ capnp.Struct }
|
|
|
|
// RegistrationOptions_TypeID is the unique identifier for the type RegistrationOptions.
|
|
const RegistrationOptions_TypeID = 0xc793e50592935b4a
|
|
|
|
func NewRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 7})
|
|
return RegistrationOptions{st}, err
|
|
}
|
|
|
|
func NewRootRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 7})
|
|
return RegistrationOptions{st}, err
|
|
}
|
|
|
|
func ReadRootRegistrationOptions(msg *capnp.Message) (RegistrationOptions, error) {
|
|
root, err := msg.RootPtr()
|
|
return RegistrationOptions{root.Struct()}, err
|
|
}
|
|
|
|
func (s RegistrationOptions) String() string {
|
|
str, _ := text.Marshal(0xc793e50592935b4a, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s RegistrationOptions) ClientId() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasClientId() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) ClientIdBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetClientId(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) Version() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasVersion() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) VersionBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetVersion(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) Os() (string, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasOs() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) OsBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetOs(v string) error {
|
|
return s.Struct.SetText(2, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) ExistingTunnelPolicy() ExistingTunnelPolicy {
|
|
return ExistingTunnelPolicy(s.Struct.Uint16(0))
|
|
}
|
|
|
|
func (s RegistrationOptions) SetExistingTunnelPolicy(v ExistingTunnelPolicy) {
|
|
s.Struct.SetUint16(0, uint16(v))
|
|
}
|
|
|
|
func (s RegistrationOptions) PoolName() (string, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasPoolName() bool {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) PoolNameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetPoolName(v string) error {
|
|
return s.Struct.SetText(3, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) Tags() (Tag_List, error) {
|
|
p, err := s.Struct.Ptr(4)
|
|
return Tag_List{List: p.List()}, err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasTags() bool {
|
|
p, err := s.Struct.Ptr(4)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) SetTags(v Tag_List) error {
|
|
return s.Struct.SetPtr(4, v.List.ToPtr())
|
|
}
|
|
|
|
// NewTags sets the tags field to a newly
|
|
// allocated Tag_List, preferring placement in s's segment.
|
|
func (s RegistrationOptions) NewTags(n int32) (Tag_List, error) {
|
|
l, err := NewTag_List(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return Tag_List{}, err
|
|
}
|
|
err = s.Struct.SetPtr(4, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
func (s RegistrationOptions) ConnectionId() uint8 {
|
|
return s.Struct.Uint8(2)
|
|
}
|
|
|
|
func (s RegistrationOptions) SetConnectionId(v uint8) {
|
|
s.Struct.SetUint8(2, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) OriginLocalIp() (string, error) {
|
|
p, err := s.Struct.Ptr(5)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasOriginLocalIp() bool {
|
|
p, err := s.Struct.Ptr(5)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) OriginLocalIpBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(5)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetOriginLocalIp(v string) error {
|
|
return s.Struct.SetText(5, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) IsAutoupdated() bool {
|
|
return s.Struct.Bit(24)
|
|
}
|
|
|
|
func (s RegistrationOptions) SetIsAutoupdated(v bool) {
|
|
s.Struct.SetBit(24, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) RunFromTerminal() bool {
|
|
return s.Struct.Bit(25)
|
|
}
|
|
|
|
func (s RegistrationOptions) SetRunFromTerminal(v bool) {
|
|
s.Struct.SetBit(25, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) CompressionQuality() uint64 {
|
|
return s.Struct.Uint64(8)
|
|
}
|
|
|
|
func (s RegistrationOptions) SetCompressionQuality(v uint64) {
|
|
s.Struct.SetUint64(8, v)
|
|
}
|
|
|
|
func (s RegistrationOptions) Uuid() (string, error) {
|
|
p, err := s.Struct.Ptr(6)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) HasUuid() bool {
|
|
p, err := s.Struct.Ptr(6)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s RegistrationOptions) UuidBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(6)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s RegistrationOptions) SetUuid(v string) error {
|
|
return s.Struct.SetText(6, v)
|
|
}
|
|
|
|
// RegistrationOptions_List is a list of RegistrationOptions.
|
|
type RegistrationOptions_List struct{ capnp.List }
|
|
|
|
// NewRegistrationOptions creates a new list of RegistrationOptions.
|
|
func NewRegistrationOptions_List(s *capnp.Segment, sz int32) (RegistrationOptions_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 7}, sz)
|
|
return RegistrationOptions_List{l}, err
|
|
}
|
|
|
|
func (s RegistrationOptions_List) At(i int) RegistrationOptions {
|
|
return RegistrationOptions{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s RegistrationOptions_List) Set(i int, v RegistrationOptions) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// RegistrationOptions_Promise is a wrapper for a RegistrationOptions promised by a client call.
|
|
type RegistrationOptions_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p RegistrationOptions_Promise) Struct() (RegistrationOptions, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return RegistrationOptions{s}, err
|
|
}
|
|
|
|
type CapnpConnectParameters struct{ capnp.Struct }
|
|
|
|
// CapnpConnectParameters_TypeID is the unique identifier for the type CapnpConnectParameters.
|
|
const CapnpConnectParameters_TypeID = 0xa78f37418c1077c8
|
|
|
|
func NewCapnpConnectParameters(s *capnp.Segment) (CapnpConnectParameters, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
|
|
return CapnpConnectParameters{st}, err
|
|
}
|
|
|
|
func NewRootCapnpConnectParameters(s *capnp.Segment) (CapnpConnectParameters, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
|
|
return CapnpConnectParameters{st}, err
|
|
}
|
|
|
|
func ReadRootCapnpConnectParameters(msg *capnp.Message) (CapnpConnectParameters, error) {
|
|
root, err := msg.RootPtr()
|
|
return CapnpConnectParameters{root.Struct()}, err
|
|
}
|
|
|
|
func (s CapnpConnectParameters) String() string {
|
|
str, _ := text.Marshal(0xa78f37418c1077c8, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s CapnpConnectParameters) OriginCert() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s CapnpConnectParameters) HasOriginCert() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s CapnpConnectParameters) SetOriginCert(v []byte) error {
|
|
return s.Struct.SetData(0, v)
|
|
}
|
|
|
|
func (s CapnpConnectParameters) CloudflaredID() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s CapnpConnectParameters) HasCloudflaredID() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s CapnpConnectParameters) SetCloudflaredID(v []byte) error {
|
|
return s.Struct.SetData(1, v)
|
|
}
|
|
|
|
func (s CapnpConnectParameters) NumPreviousAttempts() uint8 {
|
|
return s.Struct.Uint8(0)
|
|
}
|
|
|
|
func (s CapnpConnectParameters) SetNumPreviousAttempts(v uint8) {
|
|
s.Struct.SetUint8(0, v)
|
|
}
|
|
|
|
func (s CapnpConnectParameters) Tags() (Tag_List, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return Tag_List{List: p.List()}, err
|
|
}
|
|
|
|
func (s CapnpConnectParameters) HasTags() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s CapnpConnectParameters) SetTags(v Tag_List) error {
|
|
return s.Struct.SetPtr(2, v.List.ToPtr())
|
|
}
|
|
|
|
// NewTags sets the tags field to a newly
|
|
// allocated Tag_List, preferring placement in s's segment.
|
|
func (s CapnpConnectParameters) NewTags(n int32) (Tag_List, error) {
|
|
l, err := NewTag_List(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return Tag_List{}, err
|
|
}
|
|
err = s.Struct.SetPtr(2, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
func (s CapnpConnectParameters) CloudflaredVersion() (string, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s CapnpConnectParameters) HasCloudflaredVersion() bool {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s CapnpConnectParameters) CloudflaredVersionBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(3)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s CapnpConnectParameters) SetCloudflaredVersion(v string) error {
|
|
return s.Struct.SetText(3, v)
|
|
}
|
|
|
|
// CapnpConnectParameters_List is a list of CapnpConnectParameters.
|
|
type CapnpConnectParameters_List struct{ capnp.List }
|
|
|
|
// NewCapnpConnectParameters creates a new list of CapnpConnectParameters.
|
|
func NewCapnpConnectParameters_List(s *capnp.Segment, sz int32) (CapnpConnectParameters_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}, sz)
|
|
return CapnpConnectParameters_List{l}, err
|
|
}
|
|
|
|
func (s CapnpConnectParameters_List) At(i int) CapnpConnectParameters {
|
|
return CapnpConnectParameters{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s CapnpConnectParameters_List) Set(i int, v CapnpConnectParameters) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// CapnpConnectParameters_Promise is a wrapper for a CapnpConnectParameters promised by a client call.
|
|
type CapnpConnectParameters_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p CapnpConnectParameters_Promise) Struct() (CapnpConnectParameters, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return CapnpConnectParameters{s}, err
|
|
}
|
|
|
|
type ConnectResult struct{ capnp.Struct }
|
|
|
|
// ConnectResult_TypeID is the unique identifier for the type ConnectResult.
|
|
const ConnectResult_TypeID = 0xff8d9848747c956a
|
|
|
|
func NewConnectResult(s *capnp.Segment) (ConnectResult, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
|
|
return ConnectResult{st}, err
|
|
}
|
|
|
|
func NewRootConnectResult(s *capnp.Segment) (ConnectResult, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
|
|
return ConnectResult{st}, err
|
|
}
|
|
|
|
func ReadRootConnectResult(msg *capnp.Message) (ConnectResult, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConnectResult{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectResult) String() string {
|
|
str, _ := text.Marshal(0xff8d9848747c956a, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConnectResult) Err() (ConnectError, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return ConnectError{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectResult) HasErr() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectResult) SetErr(v ConnectError) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewErr sets the err field to a newly
|
|
// allocated ConnectError struct, preferring placement in s's segment.
|
|
func (s ConnectResult) NewErr() (ConnectError, error) {
|
|
ss, err := NewConnectError(s.Struct.Segment())
|
|
if err != nil {
|
|
return ConnectError{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ConnectResult) ServerInfo() (ServerInfo, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return ServerInfo{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectResult) HasServerInfo() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectResult) SetServerInfo(v ServerInfo) error {
|
|
return s.Struct.SetPtr(1, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewServerInfo sets the serverInfo field to a newly
|
|
// allocated ServerInfo struct, preferring placement in s's segment.
|
|
func (s ConnectResult) NewServerInfo() (ServerInfo, error) {
|
|
ss, err := NewServerInfo(s.Struct.Segment())
|
|
if err != nil {
|
|
return ServerInfo{}, err
|
|
}
|
|
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// ConnectResult_List is a list of ConnectResult.
|
|
type ConnectResult_List struct{ capnp.List }
|
|
|
|
// NewConnectResult creates a new list of ConnectResult.
|
|
func NewConnectResult_List(s *capnp.Segment, sz int32) (ConnectResult_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
|
|
return ConnectResult_List{l}, err
|
|
}
|
|
|
|
func (s ConnectResult_List) At(i int) ConnectResult { return ConnectResult{s.List.Struct(i)} }
|
|
|
|
func (s ConnectResult_List) Set(i int, v ConnectResult) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
// ConnectResult_Promise is a wrapper for a ConnectResult promised by a client call.
|
|
type ConnectResult_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConnectResult_Promise) Struct() (ConnectResult, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConnectResult{s}, err
|
|
}
|
|
|
|
func (p ConnectResult_Promise) Err() ConnectError_Promise {
|
|
return ConnectError_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
func (p ConnectResult_Promise) ServerInfo() ServerInfo_Promise {
|
|
return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
|
|
}
|
|
|
|
type ConnectError struct{ capnp.Struct }
|
|
|
|
// ConnectError_TypeID is the unique identifier for the type ConnectError.
|
|
const ConnectError_TypeID = 0xb14ce48f4e2abb0d
|
|
|
|
func NewConnectError(s *capnp.Segment) (ConnectError, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
|
|
return ConnectError{st}, err
|
|
}
|
|
|
|
func NewRootConnectError(s *capnp.Segment) (ConnectError, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
|
|
return ConnectError{st}, err
|
|
}
|
|
|
|
func ReadRootConnectError(msg *capnp.Message) (ConnectError, error) {
|
|
root, err := msg.RootPtr()
|
|
return ConnectError{root.Struct()}, err
|
|
}
|
|
|
|
func (s ConnectError) String() string {
|
|
str, _ := text.Marshal(0xb14ce48f4e2abb0d, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ConnectError) Cause() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s ConnectError) HasCause() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ConnectError) CauseBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s ConnectError) SetCause(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s ConnectError) RetryAfter() int64 {
|
|
return int64(s.Struct.Uint64(0))
|
|
}
|
|
|
|
func (s ConnectError) SetRetryAfter(v int64) {
|
|
s.Struct.SetUint64(0, uint64(v))
|
|
}
|
|
|
|
func (s ConnectError) ShouldRetry() bool {
|
|
return s.Struct.Bit(64)
|
|
}
|
|
|
|
func (s ConnectError) SetShouldRetry(v bool) {
|
|
s.Struct.SetBit(64, v)
|
|
}
|
|
|
|
// ConnectError_List is a list of ConnectError.
|
|
type ConnectError_List struct{ capnp.List }
|
|
|
|
// NewConnectError creates a new list of ConnectError.
|
|
func NewConnectError_List(s *capnp.Segment, sz int32) (ConnectError_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}, sz)
|
|
return ConnectError_List{l}, err
|
|
}
|
|
|
|
func (s ConnectError_List) At(i int) ConnectError { return ConnectError{s.List.Struct(i)} }
|
|
|
|
func (s ConnectError_List) Set(i int, v ConnectError) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
// ConnectError_Promise is a wrapper for a ConnectError promised by a client call.
|
|
type ConnectError_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ConnectError_Promise) Struct() (ConnectError, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ConnectError{s}, err
|
|
}
|
|
|
|
type CloudflaredConfig struct{ capnp.Struct }
|
|
|
|
// CloudflaredConfig_TypeID is the unique identifier for the type CloudflaredConfig.
|
|
const CloudflaredConfig_TypeID = 0x984a5b060f122dd1
|
|
|
|
func NewCloudflaredConfig(s *capnp.Segment) (CloudflaredConfig, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 48, PointerCount: 2})
|
|
return CloudflaredConfig{st}, err
|
|
}
|
|
|
|
func NewRootCloudflaredConfig(s *capnp.Segment) (CloudflaredConfig, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 48, PointerCount: 2})
|
|
return CloudflaredConfig{st}, err
|
|
}
|
|
|
|
func ReadRootCloudflaredConfig(msg *capnp.Message) (CloudflaredConfig, error) {
|
|
root, err := msg.RootPtr()
|
|
return CloudflaredConfig{root.Struct()}, err
|
|
}
|
|
|
|
func (s CloudflaredConfig) String() string {
|
|
str, _ := text.Marshal(0x984a5b060f122dd1, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s CloudflaredConfig) Timestamp() int64 {
|
|
return int64(s.Struct.Uint64(0))
|
|
}
|
|
|
|
func (s CloudflaredConfig) SetTimestamp(v int64) {
|
|
s.Struct.SetUint64(0, uint64(v))
|
|
}
|
|
|
|
func (s CloudflaredConfig) AutoUpdateFrequency() int64 {
|
|
return int64(s.Struct.Uint64(8))
|
|
}
|
|
|
|
func (s CloudflaredConfig) SetAutoUpdateFrequency(v int64) {
|
|
s.Struct.SetUint64(8, uint64(v))
|
|
}
|
|
|
|
func (s CloudflaredConfig) MetricsUpdateFrequency() int64 {
|
|
return int64(s.Struct.Uint64(16))
|
|
}
|
|
|
|
func (s CloudflaredConfig) SetMetricsUpdateFrequency(v int64) {
|
|
s.Struct.SetUint64(16, uint64(v))
|
|
}
|
|
|
|
func (s CloudflaredConfig) HeartbeatInterval() int64 {
|
|
return int64(s.Struct.Uint64(24))
|
|
}
|
|
|
|
func (s CloudflaredConfig) SetHeartbeatInterval(v int64) {
|
|
s.Struct.SetUint64(24, uint64(v))
|
|
}
|
|
|
|
func (s CloudflaredConfig) MaxFailedHeartbeats() uint64 {
|
|
return s.Struct.Uint64(32)
|
|
}
|
|
|
|
func (s CloudflaredConfig) SetMaxFailedHeartbeats(v uint64) {
|
|
s.Struct.SetUint64(32, v)
|
|
}
|
|
|
|
func (s CloudflaredConfig) GracePeriod() int64 {
|
|
return int64(s.Struct.Uint64(40))
|
|
}
|
|
|
|
func (s CloudflaredConfig) SetGracePeriod(v int64) {
|
|
s.Struct.SetUint64(40, uint64(v))
|
|
}
|
|
|
|
func (s CloudflaredConfig) DohProxyConfigs() (DoHProxyConfig_List, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return DoHProxyConfig_List{List: p.List()}, err
|
|
}
|
|
|
|
func (s CloudflaredConfig) HasDohProxyConfigs() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s CloudflaredConfig) SetDohProxyConfigs(v DoHProxyConfig_List) error {
|
|
return s.Struct.SetPtr(0, v.List.ToPtr())
|
|
}
|
|
|
|
// NewDohProxyConfigs sets the dohProxyConfigs field to a newly
|
|
// allocated DoHProxyConfig_List, preferring placement in s's segment.
|
|
func (s CloudflaredConfig) NewDohProxyConfigs(n int32) (DoHProxyConfig_List, error) {
|
|
l, err := NewDoHProxyConfig_List(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return DoHProxyConfig_List{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
func (s CloudflaredConfig) ReverseProxyConfigs() (ReverseProxyConfig_List, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return ReverseProxyConfig_List{List: p.List()}, err
|
|
}
|
|
|
|
func (s CloudflaredConfig) HasReverseProxyConfigs() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s CloudflaredConfig) SetReverseProxyConfigs(v ReverseProxyConfig_List) error {
|
|
return s.Struct.SetPtr(1, v.List.ToPtr())
|
|
}
|
|
|
|
// NewReverseProxyConfigs sets the reverseProxyConfigs field to a newly
|
|
// allocated ReverseProxyConfig_List, preferring placement in s's segment.
|
|
func (s CloudflaredConfig) NewReverseProxyConfigs(n int32) (ReverseProxyConfig_List, error) {
|
|
l, err := NewReverseProxyConfig_List(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return ReverseProxyConfig_List{}, err
|
|
}
|
|
err = s.Struct.SetPtr(1, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
// CloudflaredConfig_List is a list of CloudflaredConfig.
|
|
type CloudflaredConfig_List struct{ capnp.List }
|
|
|
|
// NewCloudflaredConfig creates a new list of CloudflaredConfig.
|
|
func NewCloudflaredConfig_List(s *capnp.Segment, sz int32) (CloudflaredConfig_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 48, PointerCount: 2}, sz)
|
|
return CloudflaredConfig_List{l}, err
|
|
}
|
|
|
|
func (s CloudflaredConfig_List) At(i int) CloudflaredConfig {
|
|
return CloudflaredConfig{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s CloudflaredConfig_List) Set(i int, v CloudflaredConfig) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// CloudflaredConfig_Promise is a wrapper for a CloudflaredConfig promised by a client call.
|
|
type CloudflaredConfig_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p CloudflaredConfig_Promise) Struct() (CloudflaredConfig, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return CloudflaredConfig{s}, err
|
|
}
|
|
|
|
type ReverseProxyConfig struct{ capnp.Struct }
|
|
type ReverseProxyConfig_origin ReverseProxyConfig
|
|
type ReverseProxyConfig_origin_Which uint16
|
|
|
|
const (
|
|
ReverseProxyConfig_origin_Which_http ReverseProxyConfig_origin_Which = 0
|
|
ReverseProxyConfig_origin_Which_socket ReverseProxyConfig_origin_Which = 1
|
|
ReverseProxyConfig_origin_Which_websocket ReverseProxyConfig_origin_Which = 2
|
|
ReverseProxyConfig_origin_Which_helloWorld ReverseProxyConfig_origin_Which = 3
|
|
)
|
|
|
|
func (w ReverseProxyConfig_origin_Which) String() string {
|
|
const s = "httpsocketwebsockethelloWorld"
|
|
switch w {
|
|
case ReverseProxyConfig_origin_Which_http:
|
|
return s[0:4]
|
|
case ReverseProxyConfig_origin_Which_socket:
|
|
return s[4:10]
|
|
case ReverseProxyConfig_origin_Which_websocket:
|
|
return s[10:19]
|
|
case ReverseProxyConfig_origin_Which_helloWorld:
|
|
return s[19:29]
|
|
|
|
}
|
|
return "ReverseProxyConfig_origin_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
|
|
}
|
|
|
|
// ReverseProxyConfig_TypeID is the unique identifier for the type ReverseProxyConfig.
|
|
const ReverseProxyConfig_TypeID = 0xc766a92976e389c4
|
|
|
|
func NewReverseProxyConfig(s *capnp.Segment) (ReverseProxyConfig, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 2})
|
|
return ReverseProxyConfig{st}, err
|
|
}
|
|
|
|
func NewRootReverseProxyConfig(s *capnp.Segment) (ReverseProxyConfig, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 2})
|
|
return ReverseProxyConfig{st}, err
|
|
}
|
|
|
|
func ReadRootReverseProxyConfig(msg *capnp.Message) (ReverseProxyConfig, error) {
|
|
root, err := msg.RootPtr()
|
|
return ReverseProxyConfig{root.Struct()}, err
|
|
}
|
|
|
|
func (s ReverseProxyConfig) String() string {
|
|
str, _ := text.Marshal(0xc766a92976e389c4, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ReverseProxyConfig) TunnelID() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s ReverseProxyConfig) HasTunnelID() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ReverseProxyConfig) TunnelIDBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s ReverseProxyConfig) SetTunnelID(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s ReverseProxyConfig) Origin() ReverseProxyConfig_origin { return ReverseProxyConfig_origin(s) }
|
|
|
|
func (s ReverseProxyConfig_origin) Which() ReverseProxyConfig_origin_Which {
|
|
return ReverseProxyConfig_origin_Which(s.Struct.Uint16(0))
|
|
}
|
|
func (s ReverseProxyConfig_origin) Http() (HTTPOriginConfig, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return HTTPOriginConfig{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ReverseProxyConfig_origin) HasHttp() bool {
|
|
if s.Struct.Uint16(0) != 0 {
|
|
return false
|
|
}
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ReverseProxyConfig_origin) SetHttp(v HTTPOriginConfig) error {
|
|
s.Struct.SetUint16(0, 0)
|
|
return s.Struct.SetPtr(1, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewHttp sets the http field to a newly
|
|
// allocated HTTPOriginConfig struct, preferring placement in s's segment.
|
|
func (s ReverseProxyConfig_origin) NewHttp() (HTTPOriginConfig, error) {
|
|
s.Struct.SetUint16(0, 0)
|
|
ss, err := NewHTTPOriginConfig(s.Struct.Segment())
|
|
if err != nil {
|
|
return HTTPOriginConfig{}, err
|
|
}
|
|
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ReverseProxyConfig_origin) Socket() (UnixSocketOriginConfig, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return UnixSocketOriginConfig{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ReverseProxyConfig_origin) HasSocket() bool {
|
|
if s.Struct.Uint16(0) != 1 {
|
|
return false
|
|
}
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ReverseProxyConfig_origin) SetSocket(v UnixSocketOriginConfig) error {
|
|
s.Struct.SetUint16(0, 1)
|
|
return s.Struct.SetPtr(1, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewSocket sets the socket field to a newly
|
|
// allocated UnixSocketOriginConfig struct, preferring placement in s's segment.
|
|
func (s ReverseProxyConfig_origin) NewSocket() (UnixSocketOriginConfig, error) {
|
|
s.Struct.SetUint16(0, 1)
|
|
ss, err := NewUnixSocketOriginConfig(s.Struct.Segment())
|
|
if err != nil {
|
|
return UnixSocketOriginConfig{}, err
|
|
}
|
|
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ReverseProxyConfig_origin) Websocket() (WebSocketOriginConfig, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return WebSocketOriginConfig{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ReverseProxyConfig_origin) HasWebsocket() bool {
|
|
if s.Struct.Uint16(0) != 2 {
|
|
return false
|
|
}
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ReverseProxyConfig_origin) SetWebsocket(v WebSocketOriginConfig) error {
|
|
s.Struct.SetUint16(0, 2)
|
|
return s.Struct.SetPtr(1, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewWebsocket sets the websocket field to a newly
|
|
// allocated WebSocketOriginConfig struct, preferring placement in s's segment.
|
|
func (s ReverseProxyConfig_origin) NewWebsocket() (WebSocketOriginConfig, error) {
|
|
s.Struct.SetUint16(0, 2)
|
|
ss, err := NewWebSocketOriginConfig(s.Struct.Segment())
|
|
if err != nil {
|
|
return WebSocketOriginConfig{}, err
|
|
}
|
|
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ReverseProxyConfig_origin) HelloWorld() (HelloWorldOriginConfig, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return HelloWorldOriginConfig{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s ReverseProxyConfig_origin) HasHelloWorld() bool {
|
|
if s.Struct.Uint16(0) != 3 {
|
|
return false
|
|
}
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ReverseProxyConfig_origin) SetHelloWorld(v HelloWorldOriginConfig) error {
|
|
s.Struct.SetUint16(0, 3)
|
|
return s.Struct.SetPtr(1, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewHelloWorld sets the helloWorld field to a newly
|
|
// allocated HelloWorldOriginConfig struct, preferring placement in s's segment.
|
|
func (s ReverseProxyConfig_origin) NewHelloWorld() (HelloWorldOriginConfig, error) {
|
|
s.Struct.SetUint16(0, 3)
|
|
ss, err := NewHelloWorldOriginConfig(s.Struct.Segment())
|
|
if err != nil {
|
|
return HelloWorldOriginConfig{}, err
|
|
}
|
|
err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
func (s ReverseProxyConfig) Retries() uint64 {
|
|
return s.Struct.Uint64(8)
|
|
}
|
|
|
|
func (s ReverseProxyConfig) SetRetries(v uint64) {
|
|
s.Struct.SetUint64(8, v)
|
|
}
|
|
|
|
func (s ReverseProxyConfig) ConnectionTimeout() int64 {
|
|
return int64(s.Struct.Uint64(16))
|
|
}
|
|
|
|
func (s ReverseProxyConfig) SetConnectionTimeout(v int64) {
|
|
s.Struct.SetUint64(16, uint64(v))
|
|
}
|
|
|
|
func (s ReverseProxyConfig) ChunkedEncoding() bool {
|
|
return s.Struct.Bit(16)
|
|
}
|
|
|
|
func (s ReverseProxyConfig) SetChunkedEncoding(v bool) {
|
|
s.Struct.SetBit(16, v)
|
|
}
|
|
|
|
func (s ReverseProxyConfig) CompressionQuality() uint64 {
|
|
return s.Struct.Uint64(24)
|
|
}
|
|
|
|
func (s ReverseProxyConfig) SetCompressionQuality(v uint64) {
|
|
s.Struct.SetUint64(24, v)
|
|
}
|
|
|
|
// ReverseProxyConfig_List is a list of ReverseProxyConfig.
|
|
type ReverseProxyConfig_List struct{ capnp.List }
|
|
|
|
// NewReverseProxyConfig creates a new list of ReverseProxyConfig.
|
|
func NewReverseProxyConfig_List(s *capnp.Segment, sz int32) (ReverseProxyConfig_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 32, PointerCount: 2}, sz)
|
|
return ReverseProxyConfig_List{l}, err
|
|
}
|
|
|
|
func (s ReverseProxyConfig_List) At(i int) ReverseProxyConfig {
|
|
return ReverseProxyConfig{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s ReverseProxyConfig_List) Set(i int, v ReverseProxyConfig) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// ReverseProxyConfig_Promise is a wrapper for a ReverseProxyConfig promised by a client call.
|
|
type ReverseProxyConfig_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ReverseProxyConfig_Promise) Struct() (ReverseProxyConfig, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ReverseProxyConfig{s}, err
|
|
}
|
|
|
|
func (p ReverseProxyConfig_Promise) Origin() ReverseProxyConfig_origin_Promise {
|
|
return ReverseProxyConfig_origin_Promise{p.Pipeline}
|
|
}
|
|
|
|
// ReverseProxyConfig_origin_Promise is a wrapper for a ReverseProxyConfig_origin promised by a client call.
|
|
type ReverseProxyConfig_origin_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ReverseProxyConfig_origin_Promise) Struct() (ReverseProxyConfig_origin, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ReverseProxyConfig_origin{s}, err
|
|
}
|
|
|
|
func (p ReverseProxyConfig_origin_Promise) Http() HTTPOriginConfig_Promise {
|
|
return HTTPOriginConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
|
|
}
|
|
|
|
func (p ReverseProxyConfig_origin_Promise) Socket() UnixSocketOriginConfig_Promise {
|
|
return UnixSocketOriginConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
|
|
}
|
|
|
|
func (p ReverseProxyConfig_origin_Promise) Websocket() WebSocketOriginConfig_Promise {
|
|
return WebSocketOriginConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
|
|
}
|
|
|
|
func (p ReverseProxyConfig_origin_Promise) HelloWorld() HelloWorldOriginConfig_Promise {
|
|
return HelloWorldOriginConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
|
|
}
|
|
|
|
type UnixSocketOriginConfig struct{ capnp.Struct }
|
|
|
|
// UnixSocketOriginConfig_TypeID is the unique identifier for the type UnixSocketOriginConfig.
|
|
const UnixSocketOriginConfig_TypeID = 0x935185ed60218ea3
|
|
|
|
func NewUnixSocketOriginConfig(s *capnp.Segment) (UnixSocketOriginConfig, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return UnixSocketOriginConfig{st}, err
|
|
}
|
|
|
|
func NewRootUnixSocketOriginConfig(s *capnp.Segment) (UnixSocketOriginConfig, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return UnixSocketOriginConfig{st}, err
|
|
}
|
|
|
|
func ReadRootUnixSocketOriginConfig(msg *capnp.Message) (UnixSocketOriginConfig, error) {
|
|
root, err := msg.RootPtr()
|
|
return UnixSocketOriginConfig{root.Struct()}, err
|
|
}
|
|
|
|
func (s UnixSocketOriginConfig) String() string {
|
|
str, _ := text.Marshal(0x935185ed60218ea3, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s UnixSocketOriginConfig) Path() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s UnixSocketOriginConfig) HasPath() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s UnixSocketOriginConfig) PathBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s UnixSocketOriginConfig) SetPath(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
// UnixSocketOriginConfig_List is a list of UnixSocketOriginConfig.
|
|
type UnixSocketOriginConfig_List struct{ capnp.List }
|
|
|
|
// NewUnixSocketOriginConfig creates a new list of UnixSocketOriginConfig.
|
|
func NewUnixSocketOriginConfig_List(s *capnp.Segment, sz int32) (UnixSocketOriginConfig_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return UnixSocketOriginConfig_List{l}, err
|
|
}
|
|
|
|
func (s UnixSocketOriginConfig_List) At(i int) UnixSocketOriginConfig {
|
|
return UnixSocketOriginConfig{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s UnixSocketOriginConfig_List) Set(i int, v UnixSocketOriginConfig) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// UnixSocketOriginConfig_Promise is a wrapper for a UnixSocketOriginConfig promised by a client call.
|
|
type UnixSocketOriginConfig_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p UnixSocketOriginConfig_Promise) Struct() (UnixSocketOriginConfig, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return UnixSocketOriginConfig{s}, err
|
|
}
|
|
|
|
type WebSocketOriginConfig struct{ capnp.Struct }
|
|
|
|
// WebSocketOriginConfig_TypeID is the unique identifier for the type WebSocketOriginConfig.
|
|
const WebSocketOriginConfig_TypeID = 0xf9c895683ed9ac4c
|
|
|
|
func NewWebSocketOriginConfig(s *capnp.Segment) (WebSocketOriginConfig, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return WebSocketOriginConfig{st}, err
|
|
}
|
|
|
|
func NewRootWebSocketOriginConfig(s *capnp.Segment) (WebSocketOriginConfig, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return WebSocketOriginConfig{st}, err
|
|
}
|
|
|
|
func ReadRootWebSocketOriginConfig(msg *capnp.Message) (WebSocketOriginConfig, error) {
|
|
root, err := msg.RootPtr()
|
|
return WebSocketOriginConfig{root.Struct()}, err
|
|
}
|
|
|
|
func (s WebSocketOriginConfig) String() string {
|
|
str, _ := text.Marshal(0xf9c895683ed9ac4c, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s WebSocketOriginConfig) Url() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s WebSocketOriginConfig) HasUrl() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s WebSocketOriginConfig) UrlBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s WebSocketOriginConfig) SetUrl(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
// WebSocketOriginConfig_List is a list of WebSocketOriginConfig.
|
|
type WebSocketOriginConfig_List struct{ capnp.List }
|
|
|
|
// NewWebSocketOriginConfig creates a new list of WebSocketOriginConfig.
|
|
func NewWebSocketOriginConfig_List(s *capnp.Segment, sz int32) (WebSocketOriginConfig_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return WebSocketOriginConfig_List{l}, err
|
|
}
|
|
|
|
func (s WebSocketOriginConfig_List) At(i int) WebSocketOriginConfig {
|
|
return WebSocketOriginConfig{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s WebSocketOriginConfig_List) Set(i int, v WebSocketOriginConfig) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// WebSocketOriginConfig_Promise is a wrapper for a WebSocketOriginConfig promised by a client call.
|
|
type WebSocketOriginConfig_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p WebSocketOriginConfig_Promise) Struct() (WebSocketOriginConfig, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return WebSocketOriginConfig{s}, err
|
|
}
|
|
|
|
type HTTPOriginConfig struct{ capnp.Struct }
|
|
|
|
// HTTPOriginConfig_TypeID is the unique identifier for the type HTTPOriginConfig.
|
|
const HTTPOriginConfig_TypeID = 0xe4a6a1bc139211b4
|
|
|
|
func NewHTTPOriginConfig(s *capnp.Segment) (HTTPOriginConfig, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 40, PointerCount: 3})
|
|
return HTTPOriginConfig{st}, err
|
|
}
|
|
|
|
func NewRootHTTPOriginConfig(s *capnp.Segment) (HTTPOriginConfig, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 40, PointerCount: 3})
|
|
return HTTPOriginConfig{st}, err
|
|
}
|
|
|
|
func ReadRootHTTPOriginConfig(msg *capnp.Message) (HTTPOriginConfig, error) {
|
|
root, err := msg.RootPtr()
|
|
return HTTPOriginConfig{root.Struct()}, err
|
|
}
|
|
|
|
func (s HTTPOriginConfig) String() string {
|
|
str, _ := text.Marshal(0xe4a6a1bc139211b4, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s HTTPOriginConfig) Url() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s HTTPOriginConfig) HasUrl() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s HTTPOriginConfig) UrlBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s HTTPOriginConfig) SetUrl(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s HTTPOriginConfig) TcpKeepAlive() int64 {
|
|
return int64(s.Struct.Uint64(0))
|
|
}
|
|
|
|
func (s HTTPOriginConfig) SetTcpKeepAlive(v int64) {
|
|
s.Struct.SetUint64(0, uint64(v))
|
|
}
|
|
|
|
func (s HTTPOriginConfig) DialDualStack() bool {
|
|
return s.Struct.Bit(64)
|
|
}
|
|
|
|
func (s HTTPOriginConfig) SetDialDualStack(v bool) {
|
|
s.Struct.SetBit(64, v)
|
|
}
|
|
|
|
func (s HTTPOriginConfig) TlsHandshakeTimeout() int64 {
|
|
return int64(s.Struct.Uint64(16))
|
|
}
|
|
|
|
func (s HTTPOriginConfig) SetTlsHandshakeTimeout(v int64) {
|
|
s.Struct.SetUint64(16, uint64(v))
|
|
}
|
|
|
|
func (s HTTPOriginConfig) TlsVerify() bool {
|
|
return s.Struct.Bit(65)
|
|
}
|
|
|
|
func (s HTTPOriginConfig) SetTlsVerify(v bool) {
|
|
s.Struct.SetBit(65, v)
|
|
}
|
|
|
|
func (s HTTPOriginConfig) OriginCAPool() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s HTTPOriginConfig) HasOriginCAPool() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s HTTPOriginConfig) OriginCAPoolBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s HTTPOriginConfig) SetOriginCAPool(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s HTTPOriginConfig) OriginServerName() (string, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s HTTPOriginConfig) HasOriginServerName() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s HTTPOriginConfig) OriginServerNameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s HTTPOriginConfig) SetOriginServerName(v string) error {
|
|
return s.Struct.SetText(2, v)
|
|
}
|
|
|
|
func (s HTTPOriginConfig) MaxIdleConnections() uint64 {
|
|
return s.Struct.Uint64(24)
|
|
}
|
|
|
|
func (s HTTPOriginConfig) SetMaxIdleConnections(v uint64) {
|
|
s.Struct.SetUint64(24, v)
|
|
}
|
|
|
|
func (s HTTPOriginConfig) IdleConnectionTimeout() int64 {
|
|
return int64(s.Struct.Uint64(32))
|
|
}
|
|
|
|
func (s HTTPOriginConfig) SetIdleConnectionTimeout(v int64) {
|
|
s.Struct.SetUint64(32, uint64(v))
|
|
}
|
|
|
|
// HTTPOriginConfig_List is a list of HTTPOriginConfig.
|
|
type HTTPOriginConfig_List struct{ capnp.List }
|
|
|
|
// NewHTTPOriginConfig creates a new list of HTTPOriginConfig.
|
|
func NewHTTPOriginConfig_List(s *capnp.Segment, sz int32) (HTTPOriginConfig_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 40, PointerCount: 3}, sz)
|
|
return HTTPOriginConfig_List{l}, err
|
|
}
|
|
|
|
func (s HTTPOriginConfig_List) At(i int) HTTPOriginConfig { return HTTPOriginConfig{s.List.Struct(i)} }
|
|
|
|
func (s HTTPOriginConfig_List) Set(i int, v HTTPOriginConfig) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// HTTPOriginConfig_Promise is a wrapper for a HTTPOriginConfig promised by a client call.
|
|
type HTTPOriginConfig_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p HTTPOriginConfig_Promise) Struct() (HTTPOriginConfig, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return HTTPOriginConfig{s}, err
|
|
}
|
|
|
|
type DoHProxyConfig struct{ capnp.Struct }
|
|
|
|
// DoHProxyConfig_TypeID is the unique identifier for the type DoHProxyConfig.
|
|
const DoHProxyConfig_TypeID = 0xb167b0bebe562cd0
|
|
|
|
func NewDoHProxyConfig(s *capnp.Segment) (DoHProxyConfig, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
|
|
return DoHProxyConfig{st}, err
|
|
}
|
|
|
|
func NewRootDoHProxyConfig(s *capnp.Segment) (DoHProxyConfig, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
|
|
return DoHProxyConfig{st}, err
|
|
}
|
|
|
|
func ReadRootDoHProxyConfig(msg *capnp.Message) (DoHProxyConfig, error) {
|
|
root, err := msg.RootPtr()
|
|
return DoHProxyConfig{root.Struct()}, err
|
|
}
|
|
|
|
func (s DoHProxyConfig) String() string {
|
|
str, _ := text.Marshal(0xb167b0bebe562cd0, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s DoHProxyConfig) ListenHost() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s DoHProxyConfig) HasListenHost() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s DoHProxyConfig) ListenHostBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s DoHProxyConfig) SetListenHost(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s DoHProxyConfig) ListenPort() uint16 {
|
|
return s.Struct.Uint16(0)
|
|
}
|
|
|
|
func (s DoHProxyConfig) SetListenPort(v uint16) {
|
|
s.Struct.SetUint16(0, v)
|
|
}
|
|
|
|
func (s DoHProxyConfig) Upstreams() (capnp.TextList, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return capnp.TextList{List: p.List()}, err
|
|
}
|
|
|
|
func (s DoHProxyConfig) HasUpstreams() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s DoHProxyConfig) SetUpstreams(v capnp.TextList) error {
|
|
return s.Struct.SetPtr(1, v.List.ToPtr())
|
|
}
|
|
|
|
// NewUpstreams sets the upstreams field to a newly
|
|
// allocated capnp.TextList, preferring placement in s's segment.
|
|
func (s DoHProxyConfig) NewUpstreams(n int32) (capnp.TextList, error) {
|
|
l, err := capnp.NewTextList(s.Struct.Segment(), n)
|
|
if err != nil {
|
|
return capnp.TextList{}, err
|
|
}
|
|
err = s.Struct.SetPtr(1, l.List.ToPtr())
|
|
return l, err
|
|
}
|
|
|
|
// DoHProxyConfig_List is a list of DoHProxyConfig.
|
|
type DoHProxyConfig_List struct{ capnp.List }
|
|
|
|
// NewDoHProxyConfig creates a new list of DoHProxyConfig.
|
|
func NewDoHProxyConfig_List(s *capnp.Segment, sz int32) (DoHProxyConfig_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
|
|
return DoHProxyConfig_List{l}, err
|
|
}
|
|
|
|
func (s DoHProxyConfig_List) At(i int) DoHProxyConfig { return DoHProxyConfig{s.List.Struct(i)} }
|
|
|
|
func (s DoHProxyConfig_List) Set(i int, v DoHProxyConfig) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
// DoHProxyConfig_Promise is a wrapper for a DoHProxyConfig promised by a client call.
|
|
type DoHProxyConfig_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p DoHProxyConfig_Promise) Struct() (DoHProxyConfig, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return DoHProxyConfig{s}, err
|
|
}
|
|
|
|
type HelloWorldOriginConfig struct{ capnp.Struct }
|
|
|
|
// HelloWorldOriginConfig_TypeID is the unique identifier for the type HelloWorldOriginConfig.
|
|
const HelloWorldOriginConfig_TypeID = 0x8891f360e47c30d3
|
|
|
|
func NewHelloWorldOriginConfig(s *capnp.Segment) (HelloWorldOriginConfig, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return HelloWorldOriginConfig{st}, err
|
|
}
|
|
|
|
func NewRootHelloWorldOriginConfig(s *capnp.Segment) (HelloWorldOriginConfig, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return HelloWorldOriginConfig{st}, err
|
|
}
|
|
|
|
func ReadRootHelloWorldOriginConfig(msg *capnp.Message) (HelloWorldOriginConfig, error) {
|
|
root, err := msg.RootPtr()
|
|
return HelloWorldOriginConfig{root.Struct()}, err
|
|
}
|
|
|
|
func (s HelloWorldOriginConfig) String() string {
|
|
str, _ := text.Marshal(0x8891f360e47c30d3, s.Struct)
|
|
return str
|
|
}
|
|
|
|
// HelloWorldOriginConfig_List is a list of HelloWorldOriginConfig.
|
|
type HelloWorldOriginConfig_List struct{ capnp.List }
|
|
|
|
// NewHelloWorldOriginConfig creates a new list of HelloWorldOriginConfig.
|
|
func NewHelloWorldOriginConfig_List(s *capnp.Segment, sz int32) (HelloWorldOriginConfig_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
|
|
return HelloWorldOriginConfig_List{l}, err
|
|
}
|
|
|
|
func (s HelloWorldOriginConfig_List) At(i int) HelloWorldOriginConfig {
|
|
return HelloWorldOriginConfig{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s HelloWorldOriginConfig_List) Set(i int, v HelloWorldOriginConfig) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// HelloWorldOriginConfig_Promise is a wrapper for a HelloWorldOriginConfig promised by a client call.
|
|
type HelloWorldOriginConfig_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p HelloWorldOriginConfig_Promise) Struct() (HelloWorldOriginConfig, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return HelloWorldOriginConfig{s}, err
|
|
}
|
|
|
|
type Tag struct{ capnp.Struct }
|
|
|
|
// Tag_TypeID is the unique identifier for the type Tag.
|
|
const Tag_TypeID = 0xcbd96442ae3bb01a
|
|
|
|
func NewTag(s *capnp.Segment) (Tag, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
|
|
return Tag{st}, err
|
|
}
|
|
|
|
func NewRootTag(s *capnp.Segment) (Tag, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
|
|
return Tag{st}, err
|
|
}
|
|
|
|
func ReadRootTag(msg *capnp.Message) (Tag, error) {
|
|
root, err := msg.RootPtr()
|
|
return Tag{root.Struct()}, err
|
|
}
|
|
|
|
func (s Tag) String() string {
|
|
str, _ := text.Marshal(0xcbd96442ae3bb01a, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s Tag) Name() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s Tag) HasName() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s Tag) NameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s Tag) SetName(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
func (s Tag) Value() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s Tag) HasValue() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s Tag) ValueBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s Tag) SetValue(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
// Tag_List is a list of Tag.
|
|
type Tag_List struct{ capnp.List }
|
|
|
|
// NewTag creates a new list of Tag.
|
|
func NewTag_List(s *capnp.Segment, sz int32) (Tag_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
|
|
return Tag_List{l}, err
|
|
}
|
|
|
|
func (s Tag_List) At(i int) Tag { return Tag{s.List.Struct(i)} }
|
|
|
|
func (s Tag_List) Set(i int, v Tag) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
// Tag_Promise is a wrapper for a Tag promised by a client call.
|
|
type Tag_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p Tag_Promise) Struct() (Tag, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return Tag{s}, err
|
|
}
|
|
|
|
type ExistingTunnelPolicy uint16
|
|
|
|
// ExistingTunnelPolicy_TypeID is the unique identifier for the type ExistingTunnelPolicy.
|
|
const ExistingTunnelPolicy_TypeID = 0x84cb9536a2cf6d3c
|
|
|
|
// Values of ExistingTunnelPolicy.
|
|
const (
|
|
ExistingTunnelPolicy_ignore ExistingTunnelPolicy = 0
|
|
ExistingTunnelPolicy_disconnect ExistingTunnelPolicy = 1
|
|
ExistingTunnelPolicy_balance ExistingTunnelPolicy = 2
|
|
)
|
|
|
|
// String returns the enum's constant name.
|
|
func (c ExistingTunnelPolicy) String() string {
|
|
switch c {
|
|
case ExistingTunnelPolicy_ignore:
|
|
return "ignore"
|
|
case ExistingTunnelPolicy_disconnect:
|
|
return "disconnect"
|
|
case ExistingTunnelPolicy_balance:
|
|
return "balance"
|
|
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
// ExistingTunnelPolicyFromString returns the enum value with a name,
|
|
// or the zero value if there's no such value.
|
|
func ExistingTunnelPolicyFromString(c string) ExistingTunnelPolicy {
|
|
switch c {
|
|
case "ignore":
|
|
return ExistingTunnelPolicy_ignore
|
|
case "disconnect":
|
|
return ExistingTunnelPolicy_disconnect
|
|
case "balance":
|
|
return ExistingTunnelPolicy_balance
|
|
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
type ExistingTunnelPolicy_List struct{ capnp.List }
|
|
|
|
func NewExistingTunnelPolicy_List(s *capnp.Segment, sz int32) (ExistingTunnelPolicy_List, error) {
|
|
l, err := capnp.NewUInt16List(s, sz)
|
|
return ExistingTunnelPolicy_List{l.List}, err
|
|
}
|
|
|
|
func (l ExistingTunnelPolicy_List) At(i int) ExistingTunnelPolicy {
|
|
ul := capnp.UInt16List{List: l.List}
|
|
return ExistingTunnelPolicy(ul.At(i))
|
|
}
|
|
|
|
func (l ExistingTunnelPolicy_List) Set(i int, v ExistingTunnelPolicy) {
|
|
ul := capnp.UInt16List{List: l.List}
|
|
ul.Set(i, uint16(v))
|
|
}
|
|
|
|
type ServerInfo struct{ capnp.Struct }
|
|
|
|
// ServerInfo_TypeID is the unique identifier for the type ServerInfo.
|
|
const ServerInfo_TypeID = 0xf2c68e2547ec3866
|
|
|
|
func NewServerInfo(s *capnp.Segment) (ServerInfo, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return ServerInfo{st}, err
|
|
}
|
|
|
|
func NewRootServerInfo(s *capnp.Segment) (ServerInfo, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return ServerInfo{st}, err
|
|
}
|
|
|
|
func ReadRootServerInfo(msg *capnp.Message) (ServerInfo, error) {
|
|
root, err := msg.RootPtr()
|
|
return ServerInfo{root.Struct()}, err
|
|
}
|
|
|
|
func (s ServerInfo) String() string {
|
|
str, _ := text.Marshal(0xf2c68e2547ec3866, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s ServerInfo) LocationName() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s ServerInfo) HasLocationName() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s ServerInfo) LocationNameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s ServerInfo) SetLocationName(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
// ServerInfo_List is a list of ServerInfo.
|
|
type ServerInfo_List struct{ capnp.List }
|
|
|
|
// NewServerInfo creates a new list of ServerInfo.
|
|
func NewServerInfo_List(s *capnp.Segment, sz int32) (ServerInfo_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return ServerInfo_List{l}, err
|
|
}
|
|
|
|
func (s ServerInfo_List) At(i int) ServerInfo { return ServerInfo{s.List.Struct(i)} }
|
|
|
|
func (s ServerInfo_List) Set(i int, v ServerInfo) error { return s.List.SetStruct(i, v.Struct) }
|
|
|
|
// ServerInfo_Promise is a wrapper for a ServerInfo promised by a client call.
|
|
type ServerInfo_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p ServerInfo_Promise) Struct() (ServerInfo, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return ServerInfo{s}, err
|
|
}
|
|
|
|
type UseConfigurationResult struct{ capnp.Struct }
|
|
|
|
// UseConfigurationResult_TypeID is the unique identifier for the type UseConfigurationResult.
|
|
const UseConfigurationResult_TypeID = 0xd58a254e7a792b87
|
|
|
|
func NewUseConfigurationResult(s *capnp.Segment) (UseConfigurationResult, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
|
|
return UseConfigurationResult{st}, err
|
|
}
|
|
|
|
func NewRootUseConfigurationResult(s *capnp.Segment) (UseConfigurationResult, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
|
|
return UseConfigurationResult{st}, err
|
|
}
|
|
|
|
func ReadRootUseConfigurationResult(msg *capnp.Message) (UseConfigurationResult, error) {
|
|
root, err := msg.RootPtr()
|
|
return UseConfigurationResult{root.Struct()}, err
|
|
}
|
|
|
|
func (s UseConfigurationResult) String() string {
|
|
str, _ := text.Marshal(0xd58a254e7a792b87, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s UseConfigurationResult) Success() bool {
|
|
return s.Struct.Bit(0)
|
|
}
|
|
|
|
func (s UseConfigurationResult) SetSuccess(v bool) {
|
|
s.Struct.SetBit(0, v)
|
|
}
|
|
|
|
func (s UseConfigurationResult) ErrorMessage() (string, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s UseConfigurationResult) HasErrorMessage() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s UseConfigurationResult) ErrorMessageBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s UseConfigurationResult) SetErrorMessage(v string) error {
|
|
return s.Struct.SetText(0, v)
|
|
}
|
|
|
|
// UseConfigurationResult_List is a list of UseConfigurationResult.
|
|
type UseConfigurationResult_List struct{ capnp.List }
|
|
|
|
// NewUseConfigurationResult creates a new list of UseConfigurationResult.
|
|
func NewUseConfigurationResult_List(s *capnp.Segment, sz int32) (UseConfigurationResult_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
|
|
return UseConfigurationResult_List{l}, err
|
|
}
|
|
|
|
func (s UseConfigurationResult_List) At(i int) UseConfigurationResult {
|
|
return UseConfigurationResult{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s UseConfigurationResult_List) Set(i int, v UseConfigurationResult) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// UseConfigurationResult_Promise is a wrapper for a UseConfigurationResult promised by a client call.
|
|
type UseConfigurationResult_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p UseConfigurationResult_Promise) Struct() (UseConfigurationResult, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return UseConfigurationResult{s}, err
|
|
}
|
|
|
|
type TunnelServer struct{ Client capnp.Client }
|
|
|
|
// TunnelServer_TypeID is the unique identifier for the type TunnelServer.
|
|
const TunnelServer_TypeID = 0xea58385c65416035
|
|
|
|
func (c TunnelServer) RegisterTunnel(ctx context.Context, params func(TunnelServer_registerTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_registerTunnel_Results_Promise {
|
|
if c.Client == nil {
|
|
return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "registerTunnel",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 3}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_registerTunnel_Params{Struct: s}) }
|
|
}
|
|
return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) GetServerInfo(ctx context.Context, params func(TunnelServer_getServerInfo_Params) error, opts ...capnp.CallOption) TunnelServer_getServerInfo_Results_Promise {
|
|
if c.Client == nil {
|
|
return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "getServerInfo",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_getServerInfo_Params{Struct: s}) }
|
|
}
|
|
return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) UnregisterTunnel(ctx context.Context, params func(TunnelServer_unregisterTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_unregisterTunnel_Results_Promise {
|
|
if c.Client == nil {
|
|
return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 2,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "unregisterTunnel",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 0}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_unregisterTunnel_Params{Struct: s}) }
|
|
}
|
|
return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
func (c TunnelServer) Connect(ctx context.Context, params func(TunnelServer_connect_Params) error, opts ...capnp.CallOption) TunnelServer_connect_Results_Promise {
|
|
if c.Client == nil {
|
|
return TunnelServer_connect_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 3,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "connect",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_connect_Params{Struct: s}) }
|
|
}
|
|
return TunnelServer_connect_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
|
|
type TunnelServer_Server interface {
|
|
RegisterTunnel(TunnelServer_registerTunnel) error
|
|
|
|
GetServerInfo(TunnelServer_getServerInfo) error
|
|
|
|
UnregisterTunnel(TunnelServer_unregisterTunnel) error
|
|
|
|
Connect(TunnelServer_connect) error
|
|
}
|
|
|
|
func TunnelServer_ServerToClient(s TunnelServer_Server) TunnelServer {
|
|
c, _ := s.(server.Closer)
|
|
return TunnelServer{Client: server.New(TunnelServer_Methods(nil, s), c)}
|
|
}
|
|
|
|
func TunnelServer_Methods(methods []server.Method, s TunnelServer_Server) []server.Method {
|
|
if cap(methods) == 0 {
|
|
methods = make([]server.Method, 0, 4)
|
|
}
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "registerTunnel",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_registerTunnel{c, opts, TunnelServer_registerTunnel_Params{Struct: p}, TunnelServer_registerTunnel_Results{Struct: r}}
|
|
return s.RegisterTunnel(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 1,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "getServerInfo",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_getServerInfo{c, opts, TunnelServer_getServerInfo_Params{Struct: p}, TunnelServer_getServerInfo_Results{Struct: r}}
|
|
return s.GetServerInfo(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 2,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "unregisterTunnel",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_unregisterTunnel{c, opts, TunnelServer_unregisterTunnel_Params{Struct: p}, TunnelServer_unregisterTunnel_Results{Struct: r}}
|
|
return s.UnregisterTunnel(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
|
|
})
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xea58385c65416035,
|
|
MethodID: 3,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
|
|
MethodName: "connect",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := TunnelServer_connect{c, opts, TunnelServer_connect_Params{Struct: p}, TunnelServer_connect_Results{Struct: r}}
|
|
return s.Connect(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
return methods
|
|
}
|
|
|
|
// TunnelServer_registerTunnel holds the arguments for a server call to TunnelServer.registerTunnel.
|
|
type TunnelServer_registerTunnel struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params TunnelServer_registerTunnel_Params
|
|
Results TunnelServer_registerTunnel_Results
|
|
}
|
|
|
|
// TunnelServer_getServerInfo holds the arguments for a server call to TunnelServer.getServerInfo.
|
|
type TunnelServer_getServerInfo struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params TunnelServer_getServerInfo_Params
|
|
Results TunnelServer_getServerInfo_Results
|
|
}
|
|
|
|
// TunnelServer_unregisterTunnel holds the arguments for a server call to TunnelServer.unregisterTunnel.
|
|
type TunnelServer_unregisterTunnel struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params TunnelServer_unregisterTunnel_Params
|
|
Results TunnelServer_unregisterTunnel_Results
|
|
}
|
|
|
|
// TunnelServer_connect holds the arguments for a server call to TunnelServer.connect.
|
|
type TunnelServer_connect struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params TunnelServer_connect_Params
|
|
Results TunnelServer_connect_Results
|
|
}
|
|
|
|
type TunnelServer_registerTunnel_Params struct{ capnp.Struct }
|
|
|
|
// TunnelServer_registerTunnel_Params_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Params.
|
|
const TunnelServer_registerTunnel_Params_TypeID = 0xb70431c0dc014915
|
|
|
|
func NewTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return TunnelServer_registerTunnel_Params{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
|
|
return TunnelServer_registerTunnel_Params{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_registerTunnel_Params(msg *capnp.Message) (TunnelServer_registerTunnel_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_registerTunnel_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) String() string {
|
|
str, _ := text.Marshal(0xb70431c0dc014915, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) OriginCert() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return []byte(p.Data()), err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) HasOriginCert() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) SetOriginCert(v []byte) error {
|
|
return s.Struct.SetData(0, v)
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) Hostname() (string, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.Text(), err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) HasHostname() bool {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) HostnameBytes() ([]byte, error) {
|
|
p, err := s.Struct.Ptr(1)
|
|
return p.TextBytes(), err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) SetHostname(v string) error {
|
|
return s.Struct.SetText(1, v)
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) Options() (RegistrationOptions, error) {
|
|
p, err := s.Struct.Ptr(2)
|
|
return RegistrationOptions{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) HasOptions() bool {
|
|
p, err := s.Struct.Ptr(2)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params) SetOptions(v RegistrationOptions) error {
|
|
return s.Struct.SetPtr(2, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewOptions sets the options field to a newly
|
|
// allocated RegistrationOptions struct, preferring placement in s's segment.
|
|
func (s TunnelServer_registerTunnel_Params) NewOptions() (RegistrationOptions, error) {
|
|
ss, err := NewRegistrationOptions(s.Struct.Segment())
|
|
if err != nil {
|
|
return RegistrationOptions{}, err
|
|
}
|
|
err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_registerTunnel_Params_List is a list of TunnelServer_registerTunnel_Params.
|
|
type TunnelServer_registerTunnel_Params_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_registerTunnel_Params creates a new list of TunnelServer_registerTunnel_Params.
|
|
func NewTunnelServer_registerTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
|
|
return TunnelServer_registerTunnel_Params_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params_List) At(i int) TunnelServer_registerTunnel_Params {
|
|
return TunnelServer_registerTunnel_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Params_List) Set(i int, v TunnelServer_registerTunnel_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_registerTunnel_Params_Promise is a wrapper for a TunnelServer_registerTunnel_Params promised by a client call.
|
|
type TunnelServer_registerTunnel_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_registerTunnel_Params_Promise) Struct() (TunnelServer_registerTunnel_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_registerTunnel_Params{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_registerTunnel_Params_Promise) Options() RegistrationOptions_Promise {
|
|
return RegistrationOptions_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
|
|
}
|
|
|
|
type TunnelServer_registerTunnel_Results struct{ capnp.Struct }
|
|
|
|
// TunnelServer_registerTunnel_Results_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Results.
|
|
const TunnelServer_registerTunnel_Results_TypeID = 0xf2c122394f447e8e
|
|
|
|
func NewTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_registerTunnel_Results{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_registerTunnel_Results{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_registerTunnel_Results(msg *capnp.Message) (TunnelServer_registerTunnel_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_registerTunnel_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results) String() string {
|
|
str, _ := text.Marshal(0xf2c122394f447e8e, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results) Result() (TunnelRegistration, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return TunnelRegistration{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results) HasResult() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results) SetResult(v TunnelRegistration) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewResult sets the result field to a newly
|
|
// allocated TunnelRegistration struct, preferring placement in s's segment.
|
|
func (s TunnelServer_registerTunnel_Results) NewResult() (TunnelRegistration, error) {
|
|
ss, err := NewTunnelRegistration(s.Struct.Segment())
|
|
if err != nil {
|
|
return TunnelRegistration{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_registerTunnel_Results_List is a list of TunnelServer_registerTunnel_Results.
|
|
type TunnelServer_registerTunnel_Results_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_registerTunnel_Results creates a new list of TunnelServer_registerTunnel_Results.
|
|
func NewTunnelServer_registerTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return TunnelServer_registerTunnel_Results_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results_List) At(i int) TunnelServer_registerTunnel_Results {
|
|
return TunnelServer_registerTunnel_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_registerTunnel_Results_List) Set(i int, v TunnelServer_registerTunnel_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_registerTunnel_Results_Promise is a wrapper for a TunnelServer_registerTunnel_Results promised by a client call.
|
|
type TunnelServer_registerTunnel_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_registerTunnel_Results_Promise) Struct() (TunnelServer_registerTunnel_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_registerTunnel_Results{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_registerTunnel_Results_Promise) Result() TunnelRegistration_Promise {
|
|
return TunnelRegistration_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type TunnelServer_getServerInfo_Params struct{ capnp.Struct }
|
|
|
|
// TunnelServer_getServerInfo_Params_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Params.
|
|
const TunnelServer_getServerInfo_Params_TypeID = 0xdc3ed6801961e502
|
|
|
|
func NewTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_getServerInfo_Params{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_getServerInfo_Params{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_getServerInfo_Params(msg *capnp.Message) (TunnelServer_getServerInfo_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_getServerInfo_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Params) String() string {
|
|
str, _ := text.Marshal(0xdc3ed6801961e502, s.Struct)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_getServerInfo_Params_List is a list of TunnelServer_getServerInfo_Params.
|
|
type TunnelServer_getServerInfo_Params_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_getServerInfo_Params creates a new list of TunnelServer_getServerInfo_Params.
|
|
func NewTunnelServer_getServerInfo_Params_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
|
|
return TunnelServer_getServerInfo_Params_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Params_List) At(i int) TunnelServer_getServerInfo_Params {
|
|
return TunnelServer_getServerInfo_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Params_List) Set(i int, v TunnelServer_getServerInfo_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_getServerInfo_Params_Promise is a wrapper for a TunnelServer_getServerInfo_Params promised by a client call.
|
|
type TunnelServer_getServerInfo_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_getServerInfo_Params_Promise) Struct() (TunnelServer_getServerInfo_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_getServerInfo_Params{s}, err
|
|
}
|
|
|
|
type TunnelServer_getServerInfo_Results struct{ capnp.Struct }
|
|
|
|
// TunnelServer_getServerInfo_Results_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Results.
|
|
const TunnelServer_getServerInfo_Results_TypeID = 0xe3e37d096a5b564e
|
|
|
|
func NewTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_getServerInfo_Results{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_getServerInfo_Results{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_getServerInfo_Results(msg *capnp.Message) (TunnelServer_getServerInfo_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_getServerInfo_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results) String() string {
|
|
str, _ := text.Marshal(0xe3e37d096a5b564e, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results) Result() (ServerInfo, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return ServerInfo{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results) HasResult() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results) SetResult(v ServerInfo) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewResult sets the result field to a newly
|
|
// allocated ServerInfo struct, preferring placement in s's segment.
|
|
func (s TunnelServer_getServerInfo_Results) NewResult() (ServerInfo, error) {
|
|
ss, err := NewServerInfo(s.Struct.Segment())
|
|
if err != nil {
|
|
return ServerInfo{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_getServerInfo_Results_List is a list of TunnelServer_getServerInfo_Results.
|
|
type TunnelServer_getServerInfo_Results_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_getServerInfo_Results creates a new list of TunnelServer_getServerInfo_Results.
|
|
func NewTunnelServer_getServerInfo_Results_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return TunnelServer_getServerInfo_Results_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results_List) At(i int) TunnelServer_getServerInfo_Results {
|
|
return TunnelServer_getServerInfo_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_getServerInfo_Results_List) Set(i int, v TunnelServer_getServerInfo_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_getServerInfo_Results_Promise is a wrapper for a TunnelServer_getServerInfo_Results promised by a client call.
|
|
type TunnelServer_getServerInfo_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_getServerInfo_Results_Promise) Struct() (TunnelServer_getServerInfo_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_getServerInfo_Results{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_getServerInfo_Results_Promise) Result() ServerInfo_Promise {
|
|
return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type TunnelServer_unregisterTunnel_Params struct{ capnp.Struct }
|
|
|
|
// TunnelServer_unregisterTunnel_Params_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Params.
|
|
const TunnelServer_unregisterTunnel_Params_TypeID = 0x9b87b390babc2ccf
|
|
|
|
func NewTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
|
|
return TunnelServer_unregisterTunnel_Params{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
|
|
return TunnelServer_unregisterTunnel_Params{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_unregisterTunnel_Params(msg *capnp.Message) (TunnelServer_unregisterTunnel_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_unregisterTunnel_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Params) String() string {
|
|
str, _ := text.Marshal(0x9b87b390babc2ccf, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Params) GracePeriodNanoSec() int64 {
|
|
return int64(s.Struct.Uint64(0))
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Params) SetGracePeriodNanoSec(v int64) {
|
|
s.Struct.SetUint64(0, uint64(v))
|
|
}
|
|
|
|
// TunnelServer_unregisterTunnel_Params_List is a list of TunnelServer_unregisterTunnel_Params.
|
|
type TunnelServer_unregisterTunnel_Params_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_unregisterTunnel_Params creates a new list of TunnelServer_unregisterTunnel_Params.
|
|
func NewTunnelServer_unregisterTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz)
|
|
return TunnelServer_unregisterTunnel_Params_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Params_List) At(i int) TunnelServer_unregisterTunnel_Params {
|
|
return TunnelServer_unregisterTunnel_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Params_List) Set(i int, v TunnelServer_unregisterTunnel_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_unregisterTunnel_Params_Promise is a wrapper for a TunnelServer_unregisterTunnel_Params promised by a client call.
|
|
type TunnelServer_unregisterTunnel_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_unregisterTunnel_Params_Promise) Struct() (TunnelServer_unregisterTunnel_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_unregisterTunnel_Params{s}, err
|
|
}
|
|
|
|
type TunnelServer_unregisterTunnel_Results struct{ capnp.Struct }
|
|
|
|
// TunnelServer_unregisterTunnel_Results_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Results.
|
|
const TunnelServer_unregisterTunnel_Results_TypeID = 0xa29a916d4ebdd894
|
|
|
|
func NewTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_unregisterTunnel_Results{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
|
|
return TunnelServer_unregisterTunnel_Results{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_unregisterTunnel_Results(msg *capnp.Message) (TunnelServer_unregisterTunnel_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_unregisterTunnel_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Results) String() string {
|
|
str, _ := text.Marshal(0xa29a916d4ebdd894, s.Struct)
|
|
return str
|
|
}
|
|
|
|
// TunnelServer_unregisterTunnel_Results_List is a list of TunnelServer_unregisterTunnel_Results.
|
|
type TunnelServer_unregisterTunnel_Results_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_unregisterTunnel_Results creates a new list of TunnelServer_unregisterTunnel_Results.
|
|
func NewTunnelServer_unregisterTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
|
|
return TunnelServer_unregisterTunnel_Results_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Results_List) At(i int) TunnelServer_unregisterTunnel_Results {
|
|
return TunnelServer_unregisterTunnel_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_unregisterTunnel_Results_List) Set(i int, v TunnelServer_unregisterTunnel_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_unregisterTunnel_Results_Promise is a wrapper for a TunnelServer_unregisterTunnel_Results promised by a client call.
|
|
type TunnelServer_unregisterTunnel_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_unregisterTunnel_Results_Promise) Struct() (TunnelServer_unregisterTunnel_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_unregisterTunnel_Results{s}, err
|
|
}
|
|
|
|
type TunnelServer_connect_Params struct{ capnp.Struct }
|
|
|
|
// TunnelServer_connect_Params_TypeID is the unique identifier for the type TunnelServer_connect_Params.
|
|
const TunnelServer_connect_Params_TypeID = 0xa766b24d4fe5da35
|
|
|
|
func NewTunnelServer_connect_Params(s *capnp.Segment) (TunnelServer_connect_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_connect_Params{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_connect_Params(s *capnp.Segment) (TunnelServer_connect_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_connect_Params{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_connect_Params(msg *capnp.Message) (TunnelServer_connect_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_connect_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_connect_Params) String() string {
|
|
str, _ := text.Marshal(0xa766b24d4fe5da35, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_connect_Params) Parameters() (CapnpConnectParameters, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return CapnpConnectParameters{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_connect_Params) HasParameters() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_connect_Params) SetParameters(v CapnpConnectParameters) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewParameters sets the parameters field to a newly
|
|
// allocated CapnpConnectParameters struct, preferring placement in s's segment.
|
|
func (s TunnelServer_connect_Params) NewParameters() (CapnpConnectParameters, error) {
|
|
ss, err := NewCapnpConnectParameters(s.Struct.Segment())
|
|
if err != nil {
|
|
return CapnpConnectParameters{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_connect_Params_List is a list of TunnelServer_connect_Params.
|
|
type TunnelServer_connect_Params_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_connect_Params creates a new list of TunnelServer_connect_Params.
|
|
func NewTunnelServer_connect_Params_List(s *capnp.Segment, sz int32) (TunnelServer_connect_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return TunnelServer_connect_Params_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_connect_Params_List) At(i int) TunnelServer_connect_Params {
|
|
return TunnelServer_connect_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_connect_Params_List) Set(i int, v TunnelServer_connect_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_connect_Params_Promise is a wrapper for a TunnelServer_connect_Params promised by a client call.
|
|
type TunnelServer_connect_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_connect_Params_Promise) Struct() (TunnelServer_connect_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_connect_Params{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_connect_Params_Promise) Parameters() CapnpConnectParameters_Promise {
|
|
return CapnpConnectParameters_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type TunnelServer_connect_Results struct{ capnp.Struct }
|
|
|
|
// TunnelServer_connect_Results_TypeID is the unique identifier for the type TunnelServer_connect_Results.
|
|
const TunnelServer_connect_Results_TypeID = 0xfeac5c8f4899ef7c
|
|
|
|
func NewTunnelServer_connect_Results(s *capnp.Segment) (TunnelServer_connect_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_connect_Results{st}, err
|
|
}
|
|
|
|
func NewRootTunnelServer_connect_Results(s *capnp.Segment) (TunnelServer_connect_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return TunnelServer_connect_Results{st}, err
|
|
}
|
|
|
|
func ReadRootTunnelServer_connect_Results(msg *capnp.Message) (TunnelServer_connect_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return TunnelServer_connect_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_connect_Results) String() string {
|
|
str, _ := text.Marshal(0xfeac5c8f4899ef7c, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s TunnelServer_connect_Results) Result() (ConnectResult, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return ConnectResult{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s TunnelServer_connect_Results) HasResult() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s TunnelServer_connect_Results) SetResult(v ConnectResult) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewResult sets the result field to a newly
|
|
// allocated ConnectResult struct, preferring placement in s's segment.
|
|
func (s TunnelServer_connect_Results) NewResult() (ConnectResult, error) {
|
|
ss, err := NewConnectResult(s.Struct.Segment())
|
|
if err != nil {
|
|
return ConnectResult{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// TunnelServer_connect_Results_List is a list of TunnelServer_connect_Results.
|
|
type TunnelServer_connect_Results_List struct{ capnp.List }
|
|
|
|
// NewTunnelServer_connect_Results creates a new list of TunnelServer_connect_Results.
|
|
func NewTunnelServer_connect_Results_List(s *capnp.Segment, sz int32) (TunnelServer_connect_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return TunnelServer_connect_Results_List{l}, err
|
|
}
|
|
|
|
func (s TunnelServer_connect_Results_List) At(i int) TunnelServer_connect_Results {
|
|
return TunnelServer_connect_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s TunnelServer_connect_Results_List) Set(i int, v TunnelServer_connect_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// TunnelServer_connect_Results_Promise is a wrapper for a TunnelServer_connect_Results promised by a client call.
|
|
type TunnelServer_connect_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p TunnelServer_connect_Results_Promise) Struct() (TunnelServer_connect_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return TunnelServer_connect_Results{s}, err
|
|
}
|
|
|
|
func (p TunnelServer_connect_Results_Promise) Result() ConnectResult_Promise {
|
|
return ConnectResult_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type CloudflaredServer struct{ Client capnp.Client }
|
|
|
|
// CloudflaredServer_TypeID is the unique identifier for the type CloudflaredServer.
|
|
const CloudflaredServer_TypeID = 0xf548cef9dea2a4a1
|
|
|
|
func (c CloudflaredServer) UseConfiguration(ctx context.Context, params func(CloudflaredServer_useConfiguration_Params) error, opts ...capnp.CallOption) CloudflaredServer_useConfiguration_Results_Promise {
|
|
if c.Client == nil {
|
|
return CloudflaredServer_useConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
|
|
}
|
|
call := &capnp.Call{
|
|
Ctx: ctx,
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf548cef9dea2a4a1,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:CloudflaredServer",
|
|
MethodName: "useConfiguration",
|
|
},
|
|
Options: capnp.NewCallOptions(opts),
|
|
}
|
|
if params != nil {
|
|
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
|
|
call.ParamsFunc = func(s capnp.Struct) error { return params(CloudflaredServer_useConfiguration_Params{Struct: s}) }
|
|
}
|
|
return CloudflaredServer_useConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
|
|
}
|
|
|
|
type CloudflaredServer_Server interface {
|
|
UseConfiguration(CloudflaredServer_useConfiguration) 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, 1)
|
|
}
|
|
|
|
methods = append(methods, server.Method{
|
|
Method: capnp.Method{
|
|
InterfaceID: 0xf548cef9dea2a4a1,
|
|
MethodID: 0,
|
|
InterfaceName: "tunnelrpc/tunnelrpc.capnp:CloudflaredServer",
|
|
MethodName: "useConfiguration",
|
|
},
|
|
Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
|
|
call := CloudflaredServer_useConfiguration{c, opts, CloudflaredServer_useConfiguration_Params{Struct: p}, CloudflaredServer_useConfiguration_Results{Struct: r}}
|
|
return s.UseConfiguration(call)
|
|
},
|
|
ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
|
|
})
|
|
|
|
return methods
|
|
}
|
|
|
|
// CloudflaredServer_useConfiguration holds the arguments for a server call to CloudflaredServer.useConfiguration.
|
|
type CloudflaredServer_useConfiguration struct {
|
|
Ctx context.Context
|
|
Options capnp.CallOptions
|
|
Params CloudflaredServer_useConfiguration_Params
|
|
Results CloudflaredServer_useConfiguration_Results
|
|
}
|
|
|
|
type CloudflaredServer_useConfiguration_Params struct{ capnp.Struct }
|
|
|
|
// CloudflaredServer_useConfiguration_Params_TypeID is the unique identifier for the type CloudflaredServer_useConfiguration_Params.
|
|
const CloudflaredServer_useConfiguration_Params_TypeID = 0xbcae494a1cb9c358
|
|
|
|
func NewCloudflaredServer_useConfiguration_Params(s *capnp.Segment) (CloudflaredServer_useConfiguration_Params, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return CloudflaredServer_useConfiguration_Params{st}, err
|
|
}
|
|
|
|
func NewRootCloudflaredServer_useConfiguration_Params(s *capnp.Segment) (CloudflaredServer_useConfiguration_Params, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return CloudflaredServer_useConfiguration_Params{st}, err
|
|
}
|
|
|
|
func ReadRootCloudflaredServer_useConfiguration_Params(msg *capnp.Message) (CloudflaredServer_useConfiguration_Params, error) {
|
|
root, err := msg.RootPtr()
|
|
return CloudflaredServer_useConfiguration_Params{root.Struct()}, err
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Params) String() string {
|
|
str, _ := text.Marshal(0xbcae494a1cb9c358, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Params) CloudflaredConfig() (CloudflaredConfig, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return CloudflaredConfig{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Params) HasCloudflaredConfig() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Params) SetCloudflaredConfig(v CloudflaredConfig) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewCloudflaredConfig sets the cloudflaredConfig field to a newly
|
|
// allocated CloudflaredConfig struct, preferring placement in s's segment.
|
|
func (s CloudflaredServer_useConfiguration_Params) NewCloudflaredConfig() (CloudflaredConfig, error) {
|
|
ss, err := NewCloudflaredConfig(s.Struct.Segment())
|
|
if err != nil {
|
|
return CloudflaredConfig{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// CloudflaredServer_useConfiguration_Params_List is a list of CloudflaredServer_useConfiguration_Params.
|
|
type CloudflaredServer_useConfiguration_Params_List struct{ capnp.List }
|
|
|
|
// NewCloudflaredServer_useConfiguration_Params creates a new list of CloudflaredServer_useConfiguration_Params.
|
|
func NewCloudflaredServer_useConfiguration_Params_List(s *capnp.Segment, sz int32) (CloudflaredServer_useConfiguration_Params_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return CloudflaredServer_useConfiguration_Params_List{l}, err
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Params_List) At(i int) CloudflaredServer_useConfiguration_Params {
|
|
return CloudflaredServer_useConfiguration_Params{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Params_List) Set(i int, v CloudflaredServer_useConfiguration_Params) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// CloudflaredServer_useConfiguration_Params_Promise is a wrapper for a CloudflaredServer_useConfiguration_Params promised by a client call.
|
|
type CloudflaredServer_useConfiguration_Params_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p CloudflaredServer_useConfiguration_Params_Promise) Struct() (CloudflaredServer_useConfiguration_Params, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return CloudflaredServer_useConfiguration_Params{s}, err
|
|
}
|
|
|
|
func (p CloudflaredServer_useConfiguration_Params_Promise) CloudflaredConfig() CloudflaredConfig_Promise {
|
|
return CloudflaredConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
type CloudflaredServer_useConfiguration_Results struct{ capnp.Struct }
|
|
|
|
// CloudflaredServer_useConfiguration_Results_TypeID is the unique identifier for the type CloudflaredServer_useConfiguration_Results.
|
|
const CloudflaredServer_useConfiguration_Results_TypeID = 0xabe155b01da72ed9
|
|
|
|
func NewCloudflaredServer_useConfiguration_Results(s *capnp.Segment) (CloudflaredServer_useConfiguration_Results, error) {
|
|
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return CloudflaredServer_useConfiguration_Results{st}, err
|
|
}
|
|
|
|
func NewRootCloudflaredServer_useConfiguration_Results(s *capnp.Segment) (CloudflaredServer_useConfiguration_Results, error) {
|
|
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
|
|
return CloudflaredServer_useConfiguration_Results{st}, err
|
|
}
|
|
|
|
func ReadRootCloudflaredServer_useConfiguration_Results(msg *capnp.Message) (CloudflaredServer_useConfiguration_Results, error) {
|
|
root, err := msg.RootPtr()
|
|
return CloudflaredServer_useConfiguration_Results{root.Struct()}, err
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Results) String() string {
|
|
str, _ := text.Marshal(0xabe155b01da72ed9, s.Struct)
|
|
return str
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Results) Result() (UseConfigurationResult, error) {
|
|
p, err := s.Struct.Ptr(0)
|
|
return UseConfigurationResult{Struct: p.Struct()}, err
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Results) HasResult() bool {
|
|
p, err := s.Struct.Ptr(0)
|
|
return p.IsValid() || err != nil
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Results) SetResult(v UseConfigurationResult) error {
|
|
return s.Struct.SetPtr(0, v.Struct.ToPtr())
|
|
}
|
|
|
|
// NewResult sets the result field to a newly
|
|
// allocated UseConfigurationResult struct, preferring placement in s's segment.
|
|
func (s CloudflaredServer_useConfiguration_Results) NewResult() (UseConfigurationResult, error) {
|
|
ss, err := NewUseConfigurationResult(s.Struct.Segment())
|
|
if err != nil {
|
|
return UseConfigurationResult{}, err
|
|
}
|
|
err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
|
|
return ss, err
|
|
}
|
|
|
|
// CloudflaredServer_useConfiguration_Results_List is a list of CloudflaredServer_useConfiguration_Results.
|
|
type CloudflaredServer_useConfiguration_Results_List struct{ capnp.List }
|
|
|
|
// NewCloudflaredServer_useConfiguration_Results creates a new list of CloudflaredServer_useConfiguration_Results.
|
|
func NewCloudflaredServer_useConfiguration_Results_List(s *capnp.Segment, sz int32) (CloudflaredServer_useConfiguration_Results_List, error) {
|
|
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
|
|
return CloudflaredServer_useConfiguration_Results_List{l}, err
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Results_List) At(i int) CloudflaredServer_useConfiguration_Results {
|
|
return CloudflaredServer_useConfiguration_Results{s.List.Struct(i)}
|
|
}
|
|
|
|
func (s CloudflaredServer_useConfiguration_Results_List) Set(i int, v CloudflaredServer_useConfiguration_Results) error {
|
|
return s.List.SetStruct(i, v.Struct)
|
|
}
|
|
|
|
// CloudflaredServer_useConfiguration_Results_Promise is a wrapper for a CloudflaredServer_useConfiguration_Results promised by a client call.
|
|
type CloudflaredServer_useConfiguration_Results_Promise struct{ *capnp.Pipeline }
|
|
|
|
func (p CloudflaredServer_useConfiguration_Results_Promise) Struct() (CloudflaredServer_useConfiguration_Results, error) {
|
|
s, err := p.Pipeline.Struct()
|
|
return CloudflaredServer_useConfiguration_Results{s}, err
|
|
}
|
|
|
|
func (p CloudflaredServer_useConfiguration_Results_Promise) Result() UseConfigurationResult_Promise {
|
|
return UseConfigurationResult_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
|
|
}
|
|
|
|
const schema_db8274f9144abc7e = "x\xda\xacY\x7f\x8c\x14\xf5\x15\x7fof\xf7\xe6\x0e\xee" +
|
|
"\xd8\x1df\xa1\xe7\xc5\xcb)\xc1X)P\x90\xd2\xc2\xb5" +
|
|
"\xf5~p\xe0\xed\xc9\x8f\x9d\xdb;4\x88\x09s\xbb\xdf" +
|
|
"\xdb\x1b\x98\x9dYff\x813 B\xa0\xc2E\xe5\x87" +
|
|
"\x92\x08\xd5F\xa8-j\xa9\x05kc\xb4h4m\xaa" +
|
|
"\xc6X5\xadMii\x93VI\xd5\x94XQ\x93\xd2" +
|
|
"\xa8\xd3\xbc\x99\x9d\x1f\xb7w\x1e\xd8\xf4\x9f\xcb\xe6\xcd\xfb" +
|
|
"~\xdf\xfb\xbe\xef\xe7}\xde\xfb\xbe\x9b\xb7Oh\xe7\xe6" +
|
|
"\xc7\x9f\x9e\x0c \xef\x89\xd78\xdf)\xbe~\xec\x9b\x87" +
|
|
"^\xdd\x05b\x13\xe7\xdcq\xba'u\xd1\xde\xf9g\x00" +
|
|
"\\\xf0b\xfcv\x94\xde\x8a\x0b\x00\xd2\x9b\xf1U\x80\xce" +
|
|
"\xef\xe6m}g\xddG\x07\xf6\x80\xd8\x84\xa1fL\x00" +
|
|
"X\xf0^|\x04%\xac\x11\x80w~x\xef\xd5\xeb\xce" +
|
|
"\xef\x96\xef\x1b\xad\x15GR\xfb\x0b\xa9}\xe2n\xf9a" +
|
|
"\xbc\x0d\xd0ys\xce\xd4D\xcd\xad=\x0f\x80\xdc\x845" +
|
|
"\x11m\x8e\xb4\xc5\x9a\x01\x94\xae\xa9\xa1\x9fW\xd7\xbc\x84" +
|
|
"\x80\xce\xeb\xb3O?\xbb\xff\xe7w}\x1f\xe4k\x11\xc1" +
|
|
"3\xbd\xb8\xf6?\x08(\xad\xa8\xa5\xfd\xee\xff\xe3s+" +
|
|
"\x8b\x07\x8e\x1c\x03\xf1Z\xff{\xb9\x96\xe3 \xe6,\xfc" +
|
|
"\xd3\xb9U+\x9e\x1c<\xee}\xf1\xdcQk\x9f\xa4\xa5" +
|
|
"\xc3\xee\xd2\x977'\xef\xee\xf8\xd6\xbe\xe3\xe4J\xd4q" +
|
|
"w\x93\x87jGP\xfaE-\xfd<U\xdbB\xae\x8c" +
|
|
",~n\xf5G\xdf\xb3\x1e\x07y\x0e\xc6\x9c_\xef}" +
|
|
"{\xd3u\x8f\x0d\xbe\x04\xfd\x9c\x801\x0aH\xdd1\xda" +
|
|
"\xfab\xdd?\x00\x9d3s\x8f7\x9f\xec\xff\xdbO@" +
|
|
"\x9c\x1d\xd8~k\xd2,\x0eP:?\x89l7\xfcr" +
|
|
"\xd6\xca}\xef,?E\xb6\xb9\xea\xa05LnE\xa9" +
|
|
"y2\x05\xed\x8a\xc9?\x03t\xde\x98\xbd\xfa\xf9\xe7O" +
|
|
"\x16NU{\xea\x06\xed\x99\xc9=(\xbd\xe6j\xbf\xe2" +
|
|
"jOK\xe3\xd9\x17\xe6\xc7\x9e\xae\x1c\x9c'\xa5m\xf5" +
|
|
"\xef\x93w\x07\xeaI\xe1\x96_=seO\xfa\x89\xd3" +
|
|
"Q\xef\xe67\xcc \xef\xd2\x0d\xe4]\xf3\xf9\xce\x06\xfd" +
|
|
"\x83\x9d/T\xdd\xa8\xbb\xd3\xc6\x86\x1e\x94v7\x90\xb9" +
|
|
"\x1d\x0d\xb4[\x10\x09\xb9\x09c\xd5\xce5OY\x8f\xd2" +
|
|
"\xfc)\xf4s\xce\x94\x9b)\x8c=\xb7\xdew0~\xee" +
|
|
"\xbe\x97\xaaO.\xb8W\x970Q\xda\x9b\xa0\x9f\xbb\x13" +
|
|
"\xc79@\xa7\xe9\xe4\xb7\x9f\xe8\xcc\x9fy\xb5\xca\x15\xda" +
|
|
"\\\xda8\xf5\x82\xb4m*\xfd\x1a\x9e\xba\x19\xd0\xb9\xeb" +
|
|
"k\xc3\xb7\xaf\xbcf\xe4\xad\xea0y\xe1\x9f:\x82\xd2" +
|
|
"yW\xfb=W\x9b;\xa7\\q\xe7\x1fn8\x1bA" +
|
|
"NZ\xfa;B\xccY\xb9\xfa\xd6\xf5u\xdb\xde~;" +
|
|
"\x8a\x9c\xefJn\x00e\x89\xe2\xf3\x94xP:}\xf4" +
|
|
"\xc7\xef\x90\xa1\xf8\x98\x00IkP\xda-\xd1\xcf\x1d\x92" +
|
|
"CG^\xb8\xae\x83\xad]t\xcb\xfb 6\xf1\xa3\x12" +
|
|
"\xee\xd4\xb4V\x94^\x9cF\xaa\xcfM\x13P*N\x17" +
|
|
"\x00\x9c{\xef\xe8Z\xb5x\xc6\x8b\x17\xa2\xe6\xfb\xa7_" +
|
|
" \xf3\xeat2?\xb8\xe8\x9f7^s\xefo.\x8c" +
|
|
"\x97p{\xa7\xcfB\xe90\xed#\x1d\"\xe5\x0f\x96\xfd" +
|
|
"\xe0\xf7M\x89\xa6\x8f\xc7\xc3\xf83\xd3\xd7\xa3\xf4\x1a\xe9" +
|
|
".xe\xba\x8b\xf1\xa3\x8f\x1c\xfb\xeb\xc5\xdfv\x7f2" +
|
|
"\xc6\xd3\x8b_\x19@\xa9\xa1\x91\xb6\xadk\xbcQZL" +
|
|
"\xbf\x9c\xe5'\xce\xdc0t\xe8\xe5\x8b\xe3\xf9qu\xe3" +
|
|
"N\x94\x16\xba\x0b\xe67\x92\xd3[?8\xdc\xbdo\xed" +
|
|
"\x89\xcf\xa3\xa7\x92\x1b\x9f\xa5S)\xae\xc2\xfaC[\xed" +
|
|
"\xee\x07\xeeq\xc6\xb9\xe9\x05;\x1a;Q:\xe0\xeev" +
|
|
"O\xe3f\x98\xe3\xd8e]g\x9aY\x8a\xe5\xbe\xee\xff" +
|
|
"\xcc\xcd\xcd)%\xbd\xd4\xbat\x8bj\xd9\xaa^\xe8s" +
|
|
"\xe5m\x19CSs\xc3\x19D\xb9\x1e9\x00\xb1\xb9\x15" +
|
|
"\x00Q\x9c\xb6\x06\x009Q\xec\x04hS\x0b\xbaa2" +
|
|
"'\xafZ9C\xd7\x19\xf09{\xfb\x80\xa2)z\x8e" +
|
|
"\x05\x86\xe2c\x0du3M3n6L-\xbf\xcaT" +
|
|
"\x0b\xaa\xbe\xc4\xd0\x07\xd5\x02@\x06q\xa2e\xfd\xba\xba" +
|
|
"%k\xe460{\xcc29\xc6\xc7\x00b\x08 6" +
|
|
"\xcc\x02\x90ky\x94S\x1c&J\x8a=\x84\xf5\xc0a" +
|
|
"=\xe0DG_\xa2\x19\xe5\xfc\xa0\xa6\x98,\xbf\xc4\xd0" +
|
|
"\x85A\xb5@\x9b^\x15l\xfaf/\x80\xfc\x06\x8f\xf2" +
|
|
"Y\x0eE\xc4\x14Q\xaax\xe6\x18\x80|\x96G\xf9]" +
|
|
"\x0eE\x8eK\xb9Q:\xf7,\x80\xfc.\x8f\xf2\xc7\x1c" +
|
|
"\x8a<\x9fB\x1e@\xfc\xf0 \x80\xfc1\x8f\xbd\xc8\xa1" +
|
|
"\x18\x8b\xa5\x88\xf7\xc4\xcf\x8e\x01\xf4\"\x8f\xd9z\x92\xc6" +
|
|
"\xe3)\x8c\x13Hp\x00 [K\xf2\x14r\x885)" +
|
|
"\xac\x01\x90D\xdc\x09\x90M\x92x6\xa9\x0b\x98\" " +
|
|
"H\xd7\xe11\x80\xecl\x92w#\x87\x8e\xad\x16\x99e" +
|
|
"+E\xc0\x12\xc6\x81\xc38\xa0\xa3\x94m\xa3\xbf\x94W" +
|
|
"\xd0f\xcbL\xb6\xb1\xcc\x04=7\x1c|-2\xdbT" +
|
|
"sV?\x96\xf2\x8a\xab\xd0\xb6\xb1\xcc\xa2\x0aCL1" +
|
|
"\xed\x01\xa6\xa0\x9d\xd6mfnRP\x0b\x17+[\x96" +
|
|
")\xaa\xc60\xdf\xedi\x09\x8ama\x1dpX\x07\xe8" +
|
|
"\x14L%\xc72\xcc\x04A5\xf2\xc1\x9a\xbc1\x941" +
|
|
"\x8d-\xc3\xe8\xdd\x9f\x058\x050\xc3#&C\xba\x06" +
|
|
"$\xa1c\xb2M\xcc\xb4X\x06I\x9f\xd4\x05\xb5`\x85" +
|
|
"\xea\x01\x81V\xd4\xfd[\xad\x19{\xc1\x1e\xa6\xb3\xcc\xdc" +
|
|
"\xc4\xcc\xb9e\xddd\x05\xd5\xb2\x99\xe9\x89g\xb6e\x14" +
|
|
"S)ZQ\x14\x1d\x01\x90\x93<\xcaWr\xe19P" +
|
|
"5\xf2+\x15\xdd\xc8\xf2,\x17\x1c\xc7\xb7\xd4\xf0e\x8d" +
|
|
"\xf62\xab\xac\xd9\x16\x04\xab&^\xeffX\xce\x9e\x99" +
|
|
"i\x19\xe3\xeb\x1a\x00\xb9\x9eG\xb9\x91C\xa7D_\x99" +
|
|
"\xcd\x807-L\x86\xa5\x1a\x10\x930az-\xa1\xbf" +
|
|
"K<+\x99\xca.\xa6\xe5\xa5W*0\xb6\x8d\x8cm" +
|
|
"\xe5Q\xde\x13\xc9\x84\xdd&\x80\xbc\x8bGy?\x87X" +
|
|
"I\x84{(;\xf6\xf3(?H\x89\xc0y\x89p\x98" +
|
|
"\x92\xf3~\x1e\xe5\x93\x94\x08\xbc\x97\x08?\xa5X\x9f\xe4" +
|
|
"Q>\xcd\xa1cx\xa9M\xfe\xdb\xd8\x00\x1c6\x00:" +
|
|
"\xb9JzB\x8b\xc9\xf2\xe9\xae@\xae\x97\x8b\x19\x93m" +
|
|
"R\xd1([\x1d\xb6\xcd\x8aB\xc9\xb6\xb0\x068\xac\x01" +
|
|
"L\xd8J\x14,A=\xac\x80\xc5\xdf\x13M\x96_\xcd" +
|
|
"LK\xe5\x0d}\x0cU\x8c\x13\xa6\xde\x0a&}H\xaa" +
|
|
"\x85\xb9\x86\xa9\x0a\x05U\x97\x93|\xecJ\xc7\xa9\xc4D" +
|
|
"\xa1\xa3\xae\xe5Q\x1e\xe2\xb0\x19?'1\x85\x85\xb5\x02" +
|
|
"\xc8\xebx\x945\x0e\x9b\xb9\xcfHL\x81Q\x89`\x86" +
|
|
"x\x94m\x0e\x9b\xf9OIL\xa1\xd9H\xd1.\xf1(" +
|
|
"o\xe501d\xdb%L\x865\xd4\xbb\xd26\xcb\xa5" +
|
|
"DL\x86\xedd\xe5\xae7\xb3\x01\xf7\x1b }\x0dj" +
|
|
"N\xe5\xebP\x85\x84\x81\xd7\xf2\x98\x0c;\xd6*\xa0\x08" +
|
|
"\x13\x92\xa5\x8fm\x8by\xa1(\x9b\x8a\xad\x1a:a;" +
|
|
"A\xe0\x8e\xa2\xb45\xe4\xe56\xd3\xc5>&\xc3\xce\xa3" +
|
|
"\xca,?\x8eY\x17\x9am\xf6R\xd34L\xb7,\x05" +
|
|
"{/\xbd\x1e@n\xe7Q^\xce\xa1\x8f\xc94\x85\xae" +
|
|
"\x9bG\xb9\x8f\xd8\xb9\xdd\x8b\xbe<\x00 gx\x94\xd7" +
|
|
"r\xd8\x92S\xca\x16\x0b\xae\xdcd\xb69\xdc1h\x03" +
|
|
"\xcf\xcc \xb9\xad!\xa3\xac\xe5{\x19\x08\xb69\x8c\x08" +
|
|
"\x1c\xe2\xc4\x85\xa4\xcb\xe8\x8e \xc3K\x9e\x88\x9f\xe4S" +
|
|
"\x17\x8fr&\xf4s\x05\xc9\x96\xf3(\xdfB~VP" +
|
|
"\xd2Op\xe8\xe3Q.q\xe8h\xc4\x1az\xb7\x01\xbc" +
|
|
"e\x07\xeez\xc2\x8c\xe1\xe6\x89\x00\x1c\x0a\x80N\xb9d" +
|
|
"\xd9&#\xf6\x0f\x80O\xfa_\x86\x1b\xabH*\xa3$" +
|
|
"\\\xb6\x19\xff\x0c\x01\x01\xac\xe8\x89\x1e\xa2\xc2\x00\xfd\x9d" +
|
|
"a\xb0\xc7\xcf\xeb!\xc3\xb2u\xa5\xc8\x00\xc0?\xd8v" +
|
|
"\xa3D\x08\"\xee\x0a\x1a\xde\xff\x0b$3\x8a)T\xf1" +
|
|
"\xe6\xc1\x08\xc7G\xe9\xc0]\x88\x05L\x86\x8f\xae*\x17" +
|
|
"\xc6\xb9\xf9\x8e\xb2=\xc4t[\xcd\xb9\xe6\xc6\xdc\xfc\x8c" +
|
|
"\x10\xa1A\xd4\xd2\xd7GB\xe9Gm\xc5@\x18Ja" +
|
|
"\x03\x1b\xf6\x03\xd3\xc2\x8a\x8a\xaa\x05\xf7_\x89g\x07\x08" +
|
|
"7\x85:\x13\xf97\x9a\xb7\x12z\xa5\xc7i\x0c\\<" +
|
|
"Lw\xf8\x00\x8f\xf2#\x04N\x8c\xbc\xdb\xc4\xa3\xad\xc0" +
|
|
"\xb9\xd8\x8c\x03\x88{;C\xb2w\x89\xbd\x86\xd8\xfe`" +
|
|
"\x84\xedcI\xb79\x11\x0f\xef\x0cw\x14\xe3|\x0ak" +
|
|
"\x01\xc4\xa3\xc4\xf6\x8fx%\xa0\xe2o\xba+\x02\x806" +
|
|
"\xefd\xdb)\x1fU\x166\x13\x95\xfa\xa7\xa2\xa1\xf7\xa9" +
|
|
"Ef\x94\xd1\x0e\xd247T\xd67\xb0\xfcR\xd4s" +
|
|
"F^\xd5\x0b\x10\xa4j\xce(\x96LfY\xa8\x1a\xba" +
|
|
"\\V4\x95\xb7\x87\x83-'\x8c\x16\xa5\x81\x07\x9dU" +
|
|
"\xa5\x16\x17\x92\x14\xaey~\xb8\xa4\x0e\xec\x01\xc8\xb6S" +
|
|
"\xe7\xb5\x1c\xc3K\x95\xd2\xd8\x09\x90\xed\"y\x06\xc3{" +
|
|
"\x95V`\x13@\xb6\x9b\xe4}\xd4\xd8y\xad\xa1$\xe3" +
|
|
"\xe3\x00\xd9>\x12\xaf\xc3\xb0(J\xb7\xb9\xdb\xaf%\xf9" +
|
|
"\x90\xdb\x1f\xc6\xbc\xfe\x90\xe1,\x80\xec:\x92o%y" +
|
|
"\x8dw\x01\xd20\xae\x07\xc8n!\xf9.\xb7A\x8c{" +
|
|
"\x0d\xe2\x0e4\x01\xb2w\x92\xfcn\x92\xd76\xba\xd7 " +
|
|
"\xedu\xe5{H~?\xc9\xeb\xaeHa\x1d\x80t\xc0" +
|
|
"m4\xf7\x93\xfcA\x92O\xc2\x14N\x02\x90\x0e\xe3\x11" +
|
|
"\x80\xec\x83$\x7f\x94\xe4\x93kR8\x19@\xfa\x91\xeb" +
|
|
"\xcf\xc3$?\x81n\x1e\xa9L\xb7\xd3\xf9hJ\x13\xf0" +
|
|
"\xd4\xb0\xba\xf2\x86\x15\x00\x96U\xde\x1c\xe8\xf1M\xc6H" +
|
|
"\xd0\xa3\x03\x13\xe1\xac\x05\x10\x13\x80N\xc90\xb4\x95\xa3" +
|
|
"\xa9\xe2R\x05\xbe\x02\x18H\x18z:\xefw\x05\x95\xc4" +
|
|
"Yn@KN\xd1\xd2\xa5\xc0\x13\xd5\xea(\xdbF\xb9" +
|
|
"\x04-\xd4\x07\xe7\x03\x04\x99e}\x99i\x14\xfb\x90\x99" +
|
|
"EUW\xb4\xcb\xc3V\xa2\\V\xf3c\xd2\x92\xab\x06" +
|
|
"ZK\xa9\xb5Oq\xf3\xb06\xc8\xc3\xeb\xa8q\x98\xc9" +
|
|
"\xa3</B\x15s\x88*\xbe\xca\xa3\xfc\x0d\x0e\x13D" +
|
|
"\x99\x01-lR\xb42\xbb\x9c\xc6\xa5\xbf\x8a\x11\xbd\xfe" +
|
|
"\xd3#\xaa\x88\xf5\xce\xd0z`|=\x80<\x9bGy" +
|
|
"\x11\x87\xdb\xadr.G\x87\xf6\xa3\xc0\xa8\x1c\xaf`\x16" +
|
|
"$,\xa50\xd6\x91K\xd5\x9b\x02\xb3\xbd_i}\xd0" +
|
|
"\xf0I\xfa\x7f\\}\xd9]G0\x07\xb84\xadw\xf7" +
|
|
"\xf5e\xc2\xe7&\xef\x91\xe6\xcc`\xff\xf33\xc2\xe7\x9e" +
|
|
"\x1f\xae\x0f)\\\xff\xe2Q\xfe4\xd2y\\\xa4\x16\xf9" +
|
|
"\xdf<fc\x18\xf6\xc3\x12\xba\xcf\xb7\x18eO\xd2\xcd" +
|
|
"\xfe\x0e/\xfb\x1b\xb0\x17 [O\xf2F7\xfb=\xee" +
|
|
"\x95\xa6\xb9Y\x9e\"\xf9U\xd1\xeco\xc6\x11\x80\xecU" +
|
|
"\xe1\xf3\x90\xf7\x9f\x87G\xfc\xe7\xe1\"7\xfbc^\xf6" +
|
|
"/\xc4'\x01\xb2\x8bH\xde\x85\x1c\x0ae3\xac,v" +
|
|
"\xaet\x13c\xa5\x0eHh\xea&\x16>\xdbTE\xeb" +
|
|
"*+\x1a\xb4dm%\xb7!l\x864\xab[\xd1\xf3" +
|
|
"\x16\x0e)\x1b\x181\xb3`\x94Cf\xb65k53" +
|
|
"\xd5A\xc0\xb0}\x0aJW\"c\x18\xd5\x15-\xcb\x90" +
|
|
"\xee\xd3K\xf5\xe0[Q\xd9\x92\xcekl\x09Vr\xda" +
|
|
"\xe0\xf5\xb02\xa8\xf4\xc5\xd0ut\xbf\xe8}j\x0b\x95" +
|
|
"\x07{\xcc\x0b\x8d\xff\"0\xb5y\x18\xa2\x9bM\xf2q" +
|
|
"\x80`\x10\x88\xfeDI\xdcx;p\xa2*`8\xfd" +
|
|
"B\x7f\xd8%\xdef\x02'\xf6\x0b\xc8\x05CW\xf4\x87" +
|
|
"\xabbz\x048q\xa9\x80|0UE\x7f\x9e#." +
|
|
"\xee\x04N\x9c#8~\xcb\x05m\x9e;\xed\xe8\xf8\xb8" +
|
|
"\x86\x16\x17\xd9\xed\xe8\xf8\xcfG\xf4[3\x80v\xdc^" +
|
|
"\xe1\xb8v\x8c\x8eN\xbed\x8b\xd7\xcbZ\xac\xcb\xc9\x1a" +
|
|
"\x7f v\xe9N\xdd\xb3\x93 \xcf\xabf3\xeb#/" +
|
|
"U\xcd\xa8\xb4J\x89\x95\x11>\x9b(\x17=\x87\xfd\xd2" +
|
|
"\x9c\xa0\xc5U\x8fS\xca\xc6-<\xca\xbb\"\xd4\xb9c" +
|
|
"F\xe4\xc5\xeawY\xbb{*M\xcc\xc3A)\x16\x1f" +
|
|
"\x1a\x01\x90\x1f\xe6Q>\x11y\x9c>F\x8a\x8f\xf2(" +
|
|
"?\xc5\xa1\xc0L\xd3\xf7sT\xcahFa\xb9\xaa3" +
|
|
"\x8b\x8aSU\xdf]bfQ\xd1\x99\x8e\xf62E\xd5" +
|
|
"\xca&\xa1z\xf4;bT\xf7s\x99C\xaa,3\x85" +
|
|
"\x0abc.b\xfd\xc94\xfa\x03tQ$\xe45\x08" +
|
|
"\x8e\xdf\x08\xa3\xcf\xfb\x04\x9cKL\xdanf\x03\xe3\x0c" +
|
|
"\xda\xaa\xeerF\x88\x91\xd1\xfc\xf1\xc5\xfb\x8e;\xd0\xe8" +
|
|
"mc\x97\x85\xbfp\xceyi\xd6\xae\x8c1*%\xae" +
|
|
"\xaa\xc2\xcd\x18\xaf\xbe\xae\x09K\x9c{\xcd\xc9\xf0?\x0d" +
|
|
"\x15sV\xa5\xd0\x00?h\x8c\xad!\xff\x0d\x00\x00\xff" +
|
|
"\xff\xf8\xb3\xea\x07"
|
|
|
|
func init() {
|
|
schemas.Register(schema_db8274f9144abc7e,
|
|
0x84cb9536a2cf6d3c,
|
|
0x8891f360e47c30d3,
|
|
0x935185ed60218ea3,
|
|
0x984a5b060f122dd1,
|
|
0x9b87b390babc2ccf,
|
|
0xa29a916d4ebdd894,
|
|
0xa766b24d4fe5da35,
|
|
0xa78f37418c1077c8,
|
|
0xaa7386f356bd398a,
|
|
0xabe155b01da72ed9,
|
|
0xb14ce48f4e2abb0d,
|
|
0xb167b0bebe562cd0,
|
|
0xb70431c0dc014915,
|
|
0xbcae494a1cb9c358,
|
|
0xc082ef6e0d42ed1d,
|
|
0xc766a92976e389c4,
|
|
0xc793e50592935b4a,
|
|
0xcbd96442ae3bb01a,
|
|
0xd58a254e7a792b87,
|
|
0xdc3ed6801961e502,
|
|
0xe3e37d096a5b564e,
|
|
0xe4a6a1bc139211b4,
|
|
0xea58385c65416035,
|
|
0xf2c122394f447e8e,
|
|
0xf2c68e2547ec3866,
|
|
0xf41a0f001ad49e46,
|
|
0xf548cef9dea2a4a1,
|
|
0xf9c895683ed9ac4c,
|
|
0xfeac5c8f4899ef7c,
|
|
0xff8d9848747c956a)
|
|
}
|