cloudflared-mirror/tunnelrpc/tunnelrpc.capnp.go

1359 lines
46 KiB
Go
Raw Normal View History

// Code generated by capnpc-go. DO NOT EDIT.
package tunnelrpc
import (
context "golang.org/x/net/context"
capnp "zombiezen.com/go/capnproto2"
text "zombiezen.com/go/capnproto2/encoding/text"
schemas "zombiezen.com/go/capnproto2/schemas"
server "zombiezen.com/go/capnproto2/server"
)
type Authentication struct{ capnp.Struct }
// Authentication_TypeID is the unique identifier for the type Authentication.
const Authentication_TypeID = 0xc082ef6e0d42ed1d
func NewAuthentication(s *capnp.Segment) (Authentication, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return Authentication{st}, err
}
func NewRootAuthentication(s *capnp.Segment) (Authentication, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
return Authentication{st}, err
}
func ReadRootAuthentication(msg *capnp.Message) (Authentication, error) {
root, err := msg.RootPtr()
return Authentication{root.Struct()}, err
}
func (s Authentication) String() string {
str, _ := text.Marshal(0xc082ef6e0d42ed1d, s.Struct)
return str
}
func (s Authentication) Key() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Authentication) HasKey() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Authentication) KeyBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Authentication) SetKey(v string) error {
return s.Struct.SetText(0, v)
}
func (s Authentication) Email() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s Authentication) HasEmail() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s Authentication) EmailBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s Authentication) SetEmail(v string) error {
return s.Struct.SetText(1, v)
}
func (s Authentication) OriginCAKey() (string, error) {
p, err := s.Struct.Ptr(2)
return p.Text(), err
}
func (s Authentication) HasOriginCAKey() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s Authentication) OriginCAKeyBytes() ([]byte, error) {
p, err := s.Struct.Ptr(2)
return p.TextBytes(), err
}
func (s Authentication) SetOriginCAKey(v string) error {
return s.Struct.SetText(2, v)
}
// Authentication_List is a list of Authentication.
type Authentication_List struct{ capnp.List }
// NewAuthentication creates a new list of Authentication.
func NewAuthentication_List(s *capnp.Segment, sz int32) (Authentication_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
return Authentication_List{l}, err
}
func (s Authentication_List) At(i int) Authentication { return Authentication{s.List.Struct(i)} }
func (s Authentication_List) Set(i int, v Authentication) error { return s.List.SetStruct(i, v.Struct) }
// Authentication_Promise is a wrapper for a Authentication promised by a client call.
type Authentication_Promise struct{ *capnp.Pipeline }
func (p Authentication_Promise) Struct() (Authentication, error) {
s, err := p.Pipeline.Struct()
return Authentication{s}, err
}
type TunnelRegistration struct{ capnp.Struct }
// TunnelRegistration_TypeID is the unique identifier for the type TunnelRegistration.
const TunnelRegistration_TypeID = 0xf41a0f001ad49e46
func NewTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
return TunnelRegistration{st}, err
}
func NewRootTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
return TunnelRegistration{st}, err
}
func ReadRootTunnelRegistration(msg *capnp.Message) (TunnelRegistration, error) {
root, err := msg.RootPtr()
return TunnelRegistration{root.Struct()}, err
}
func (s TunnelRegistration) String() string {
str, _ := text.Marshal(0xf41a0f001ad49e46, s.Struct)
return str
}
func (s TunnelRegistration) Err() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s TunnelRegistration) HasErr() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) ErrBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s TunnelRegistration) SetErr(v string) error {
return s.Struct.SetText(0, v)
}
func (s TunnelRegistration) Url() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s TunnelRegistration) HasUrl() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) UrlBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s TunnelRegistration) SetUrl(v string) error {
return s.Struct.SetText(1, v)
}
func (s TunnelRegistration) LogLines() (capnp.TextList, error) {
p, err := s.Struct.Ptr(2)
return capnp.TextList{List: p.List()}, err
}
func (s TunnelRegistration) HasLogLines() bool {
p, err := s.Struct.Ptr(2)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) SetLogLines(v capnp.TextList) error {
return s.Struct.SetPtr(2, v.List.ToPtr())
}
// NewLogLines sets the logLines field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s TunnelRegistration) NewLogLines(n int32) (capnp.TextList, error) {
l, err := capnp.NewTextList(s.Struct.Segment(), n)
if err != nil {
return capnp.TextList{}, err
}
err = s.Struct.SetPtr(2, l.List.ToPtr())
return l, err
}
func (s TunnelRegistration) PermanentFailure() bool {
return s.Struct.Bit(0)
}
func (s TunnelRegistration) SetPermanentFailure(v bool) {
s.Struct.SetBit(0, v)
}
func (s TunnelRegistration) TunnelID() (string, error) {
p, err := s.Struct.Ptr(3)
return p.Text(), err
}
func (s TunnelRegistration) HasTunnelID() bool {
p, err := s.Struct.Ptr(3)
return p.IsValid() || err != nil
}
func (s TunnelRegistration) TunnelIDBytes() ([]byte, error) {
p, err := s.Struct.Ptr(3)
return p.TextBytes(), err
}
func (s TunnelRegistration) SetTunnelID(v string) error {
return s.Struct.SetText(3, v)
}
// TunnelRegistration_List is a list of TunnelRegistration.
type TunnelRegistration_List struct{ capnp.List }
// NewTunnelRegistration creates a new list of TunnelRegistration.
func NewTunnelRegistration_List(s *capnp.Segment, sz int32) (TunnelRegistration_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}, sz)
return TunnelRegistration_List{l}, err
}
func (s TunnelRegistration_List) At(i int) TunnelRegistration {
return TunnelRegistration{s.List.Struct(i)}
}
func (s TunnelRegistration_List) Set(i int, v TunnelRegistration) error {
return s.List.SetStruct(i, v.Struct)
}
// TunnelRegistration_Promise is a wrapper for a TunnelRegistration promised by a client call.
type TunnelRegistration_Promise struct{ *capnp.Pipeline }
func (p TunnelRegistration_Promise) Struct() (TunnelRegistration, error) {
s, err := p.Pipeline.Struct()
return TunnelRegistration{s}, err
}
type RegistrationOptions struct{ capnp.Struct }
// RegistrationOptions_TypeID is the unique identifier for the type RegistrationOptions.
const RegistrationOptions_TypeID = 0xc793e50592935b4a
func NewRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 6})
return RegistrationOptions{st}, err
}
func NewRootRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 6})
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)
}
// 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: 6}, 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 Tag struct{ capnp.Struct }
// Tag_TypeID is the unique identifier for the type Tag.
const Tag_TypeID = 0xcbd96442ae3bb01a
func NewTag(s *capnp.Segment) (Tag, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
return Tag{st}, err
}
func NewRootTag(s *capnp.Segment) (Tag, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
return Tag{st}, err
}
func ReadRootTag(msg *capnp.Message) (Tag, error) {
root, err := msg.RootPtr()
return Tag{root.Struct()}, err
}
func (s Tag) String() string {
str, _ := text.Marshal(0xcbd96442ae3bb01a, s.Struct)
return str
}
func (s Tag) Name() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s Tag) HasName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s Tag) NameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s Tag) SetName(v string) error {
return s.Struct.SetText(0, v)
}
func (s Tag) Value() (string, error) {
p, err := s.Struct.Ptr(1)
return p.Text(), err
}
func (s Tag) HasValue() bool {
p, err := s.Struct.Ptr(1)
return p.IsValid() || err != nil
}
func (s Tag) ValueBytes() ([]byte, error) {
p, err := s.Struct.Ptr(1)
return p.TextBytes(), err
}
func (s Tag) SetValue(v string) error {
return s.Struct.SetText(1, v)
}
// Tag_List is a list of Tag.
type Tag_List struct{ capnp.List }
// NewTag creates a new list of Tag.
func NewTag_List(s *capnp.Segment, sz int32) (Tag_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
return Tag_List{l}, err
}
func (s Tag_List) At(i int) Tag { return Tag{s.List.Struct(i)} }
func (s Tag_List) Set(i int, v Tag) error { return s.List.SetStruct(i, v.Struct) }
// Tag_Promise is a wrapper for a Tag promised by a client call.
type Tag_Promise struct{ *capnp.Pipeline }
func (p Tag_Promise) Struct() (Tag, error) {
s, err := p.Pipeline.Struct()
return Tag{s}, err
}
type ExistingTunnelPolicy uint16
// ExistingTunnelPolicy_TypeID is the unique identifier for the type ExistingTunnelPolicy.
const ExistingTunnelPolicy_TypeID = 0x84cb9536a2cf6d3c
// Values of ExistingTunnelPolicy.
const (
ExistingTunnelPolicy_ignore ExistingTunnelPolicy = 0
ExistingTunnelPolicy_disconnect ExistingTunnelPolicy = 1
ExistingTunnelPolicy_balance ExistingTunnelPolicy = 2
)
// String returns the enum's constant name.
func (c ExistingTunnelPolicy) String() string {
switch c {
case ExistingTunnelPolicy_ignore:
return "ignore"
case ExistingTunnelPolicy_disconnect:
return "disconnect"
case ExistingTunnelPolicy_balance:
return "balance"
default:
return ""
}
}
// ExistingTunnelPolicyFromString returns the enum value with a name,
// or the zero value if there's no such value.
func ExistingTunnelPolicyFromString(c string) ExistingTunnelPolicy {
switch c {
case "ignore":
return ExistingTunnelPolicy_ignore
case "disconnect":
return ExistingTunnelPolicy_disconnect
case "balance":
return ExistingTunnelPolicy_balance
default:
return 0
}
}
type ExistingTunnelPolicy_List struct{ capnp.List }
func NewExistingTunnelPolicy_List(s *capnp.Segment, sz int32) (ExistingTunnelPolicy_List, error) {
l, err := capnp.NewUInt16List(s, sz)
return ExistingTunnelPolicy_List{l.List}, err
}
func (l ExistingTunnelPolicy_List) At(i int) ExistingTunnelPolicy {
ul := capnp.UInt16List{List: l.List}
return ExistingTunnelPolicy(ul.At(i))
}
func (l ExistingTunnelPolicy_List) Set(i int, v ExistingTunnelPolicy) {
ul := capnp.UInt16List{List: l.List}
ul.Set(i, uint16(v))
}
type ServerInfo struct{ capnp.Struct }
// ServerInfo_TypeID is the unique identifier for the type ServerInfo.
const ServerInfo_TypeID = 0xf2c68e2547ec3866
func NewServerInfo(s *capnp.Segment) (ServerInfo, error) {
st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return ServerInfo{st}, err
}
func NewRootServerInfo(s *capnp.Segment) (ServerInfo, error) {
st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
return ServerInfo{st}, err
}
func ReadRootServerInfo(msg *capnp.Message) (ServerInfo, error) {
root, err := msg.RootPtr()
return ServerInfo{root.Struct()}, err
}
func (s ServerInfo) String() string {
str, _ := text.Marshal(0xf2c68e2547ec3866, s.Struct)
return str
}
func (s ServerInfo) LocationName() (string, error) {
p, err := s.Struct.Ptr(0)
return p.Text(), err
}
func (s ServerInfo) HasLocationName() bool {
p, err := s.Struct.Ptr(0)
return p.IsValid() || err != nil
}
func (s ServerInfo) LocationNameBytes() ([]byte, error) {
p, err := s.Struct.Ptr(0)
return p.TextBytes(), err
}
func (s ServerInfo) SetLocationName(v string) error {
return s.Struct.SetText(0, v)
}
// ServerInfo_List is a list of ServerInfo.
type ServerInfo_List struct{ capnp.List }
// NewServerInfo creates a new list of ServerInfo.
func NewServerInfo_List(s *capnp.Segment, sz int32) (ServerInfo_List, error) {
l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
return ServerInfo_List{l}, err
}
func (s ServerInfo_List) At(i int) ServerInfo { return ServerInfo{s.List.Struct(i)} }
func (s ServerInfo_List) Set(i int, v ServerInfo) error { return s.List.SetStruct(i, v.Struct) }
// ServerInfo_Promise is a wrapper for a ServerInfo promised by a client call.
type ServerInfo_Promise struct{ *capnp.Pipeline }
func (p ServerInfo_Promise) Struct() (ServerInfo, error) {
s, err := p.Pipeline.Struct()
return ServerInfo{s}, err
}
type TunnelServer struct{ Client capnp.Client }
// TunnelServer_TypeID is the unique identifier for the type TunnelServer.
const TunnelServer_TypeID = 0xea58385c65416035
func (c TunnelServer) RegisterTunnel(ctx context.Context, params func(TunnelServer_registerTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_registerTunnel_Results_Promise {
if c.Client == nil {
return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 0,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "registerTunnel",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 3}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_registerTunnel_Params{Struct: s}) }
}
return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
func (c TunnelServer) GetServerInfo(ctx context.Context, params func(TunnelServer_getServerInfo_Params) error, opts ...capnp.CallOption) TunnelServer_getServerInfo_Results_Promise {
if c.Client == nil {
return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 1,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "getServerInfo",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_getServerInfo_Params{Struct: s}) }
}
return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
func (c TunnelServer) UnregisterTunnel(ctx context.Context, params func(TunnelServer_unregisterTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_unregisterTunnel_Results_Promise {
if c.Client == nil {
return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
}
call := &capnp.Call{
Ctx: ctx,
Method: capnp.Method{
InterfaceID: 0xea58385c65416035,
MethodID: 2,
InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
MethodName: "unregisterTunnel",
},
Options: capnp.NewCallOptions(opts),
}
if params != nil {
call.ParamsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 0}
call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_unregisterTunnel_Params{Struct: s}) }
}
return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}
type TunnelServer_Server interface {
RegisterTunnel(TunnelServer_registerTunnel) error
GetServerInfo(TunnelServer_getServerInfo) error
UnregisterTunnel(TunnelServer_unregisterTunnel) 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, 3)
}
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},
})
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
}
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
}
const schema_db8274f9144abc7e = "x\xda\x9cV]\x8c\x14\xd5\x12\xae\xef\x9c\x99\xedY\xb2" +
"\xcbl\xa7\x87\\\x98\\2\x09Y\xc2OX.\\\xe0" +
"f\xd9{\xaf\xfb\xe3\x82\x99uY\xa6\x190\x08\x98\xd0" +
"\xcc\x1c\x86^{\xba'\xdd=\x08D~$\x18\x95(" +
"Q\x91\x071\x18$1Qc\xfc\x89&\x06\x83\x09\xbe" +
"H\x0c1\xbc\xa8\x91Hb\x94\xec\x03DC\xdc\xe8\x83" +
"&\xa6\xcd\xe9\xd9\x9ei\x16\x05\xf4\xed\xccw\xeaT}" +
"U]\xf5\xd5,\xfb\x07\x1f`\xcb\x93\xdf$\x89\xf4\xe1" +
"d[\xf0\xbf\xea\xa53\xff9q\xf1\x08\xa9Y\x16\x1c" +
"87\x92\xf9\xc5?\xfc5\x11V|\xc1\xf6A\xbb\xc6" +
"\x14\"m\x82\xad'\x04\x97\x96\x9c\xfb\xf0\xd9\xf7\x9ex" +
"\x89\xf4\x05\x00QB!Z\xf1\x1b\xfb\x15\x04M\xe5\xfd" +
"\x84\xe0\x85\xaf>\x1a\xab>w\xf2\x0c\xa9\x0b\xa2\xfb\xd5" +
"\x9c1J\x04\xb3\xf2\xb8r~y\xe2\x83\xc6M\x92\xcb" +
"\xab\x1e~]>\x1d\xe4o\x13\x82\xb9?\x0cu\xda7" +
"\x0e\x9f'5\x8b\x16\x8b\x86\xe1\xb7|\x04\xda\xcf\xf2\xa8" +
"\xfd\x18\x1a\x8fl=\xfe|r\xe2\xf8\x05\xd2\xb3\x88q" +
"N\xb6I\xebg\x12.\xb4W\xc2\xe0\xa7\x12\x0e#\x04" +
"\xd9w\xfe\xfb\xd6P\xf9\xf2\xc5i\xbe\xc3\xcc\xd6)\x93" +
"\xda\x83\x8a<mR\x1e!\x04l\xc2\x98s\xe8\xcb{" +
"\xae\xc4RxW\xf9\x0e\x94\x08\xc6\x1e\xd8:\xde\xbe\xff" +
"\xea\xd5\xa9\x14 \xaf^U\xc2\x14\xce*2\xfbU\xdb" +
"\x07\xc5\xb6\xde\xcd\xd7I\xcd\xf2\x9b\x0ayY\xe9\x83v" +
"-\x0c2\xa1\\\xd0\xaa)\x85(8v`x\xfd\xea" +
"y\x1fO\xc6\xddmJMJwfJ\xba\xdb\xd9\xfb" +
"\xfd}\xf3\x8f}29\x8duh\xf8Tj1\xb4\x17" +
"\xa5\x1f\xed\x844\xbe\xb1\xf6\xe5\xcf\xb3\xe9\xecOz\x16" +
"q\xdb\x90\xfe\xd9\xd48\xb4\xcf\xa4\xed\x8aOS9P" +
"O\xe0\xd7m[Xn-Q\xfaWt,--\x19" +
"5\xbb\xd6\xb7f\x8f\xe9\xf9\xa6]\xd9\x18\xe2\xfd\x05\xc7" +
"2K{\x0b\x80\xde\x01F\xa4\xce\xed#\x02\xd4Y[" +
"\x88\xc0Tu\x88\xa8\xdf\xac\xd8\x8e+\x82\xb2\xe9\x95\x1c" +
"\xdb\x16\xc4K\xfe\xc1\x1d\x86e\xd8%\xd1\x0c\xd4vk" +
"\xa0F\x80\xa2pw\x0bwi\xddvE\xc5\xf4|\xe1" +
"6\xe0\xee\xfe\x82\xe1\x1aUOO\xf0\x04Q\x02Dj" +
"\xe7I\"\xbd\x8bC\xff'CPq\x8d\x92(\x08\x17" +
"\xa6S\x1e3l\xa7\xc8E\x09IbH\x12\x9aAg" +
"\xfe\xd5\xa0\x1b\x84W\xb7|\x8f\x9a\xafn\xff~\xda\xeb" +
"\x82\x91\x0e)w4)\xaf\xd9\"'\x8cC/0\xa8" +
"@F\xce\x8c\xban\x84H\x1f\xe5\xd073\xa8\x8ce" +
"\xc2\xb2n\x1a\"\xd2\x0b\x1c\xfa6\x86\xc0q\xcd\x8ai" +
"\xdf+\x88\xbb>:\x89\xa1\x93\x10\xecr<\xdf6\xaa" +
"\x82\x88\xd0A\x0c\x1d\x84\x83N\xcd7\x1d\xdbCWk" +
"\x1e\x08\xe8\x8a\x95\xe0\x0f>\xf0`\xdd\xdf%l\xdf," +
"\x19\xf21Q\xf8m[\x94\xe7\x11\xe9\x03\x1c\xfah\x8c" +
"r\xfe\xdf\xb1<\"\xca\xebv\xb4\xf2P\x1e\x16{#" +
"V9Q5L+\xfa\x15%3H\xca\xfd-\x9b\xdb" +
"\xf1\xdb\x10V\xd5\x0d\xd9\xad\xaf\xe5\xc2\x0c%\xc7%\x11" +
"Gm>F\x88\x8a\xdd\xe0(.C\x8b\xa6\xd6\x83!" +
"\xa2\xe2B\x89\xafD\x8b\xa9\xb6\x1cY\xa2\xe2\x12\x89\xf7" +
"\x82\x01<\x03N\xa4\xad\xc2\x1bD\xc5^\x09\x0fK\xf3" +
"\x04\xcf A\xa4\x0d\x86\xee\x07$>*\xf1d\"\x83" +
"$\x91\x96\xc7b\xa2\xe2\xb0\xc4\xb7K\xbc\x8de\xd0F" +
"\xa4=\x84q\xa2\xe26\x89\xef\x92\xb8\x92\xcc\xc8\x11\xd5" +
"\x04\\\xa2bY\xe25\x89\xa7fg\x90\"\xd2\xaa!" +
"nI|\x8f\xc4\xdb\xe7d\xd0N\xa4\xd5q\x98\xa8\xe8" +
"K\xfc\x90\xc4g \x83\x19D\xda~\x9c$*\x1e\x92" +
"\xf8\xd3`\x08J\x96)l?_\x8ew\xc2n\xe1z" +
"\xa6cG\xbf\xb9\xe35K-\xa6\x06\x1a\x8d6-8" +
"i9\xd1H\xb7d\x9f\x804!\xa89\x8e5vs" +
"\x87\xa5}\xa3\xe2a&\xa1\xc0\x81\xae\x96\x8c\x12$\x18" +
"\x84\xf3^\xf2MJ;v\xbe\x8c6bhk~\xf2" +
"Q\x87r%\xc3\xca\xd7\x9aLLo\xb0\xee;\xf5\x1a" +
"\xe5\xca\x86/\xca\x001\x80\x10\xb8u{\xad\xebT7" +
"B\xb8U\xd36,j\xde\x94\x9cj\xcd\x15\x9e\x07\xd3" +
"\xb1\xf5\xbaa\x99\xdc\xdf\x8bvbh\x8f\xf5\x10\x9b\xde" +
"C\xb9Z\xdfF\xa3\"{&\xd5\xec\xebE\x8b\x89\xf4" +
"n\x0e}Y\xac\xaf{d_/\xe4\xd0W2\xa4\xe5" +
"p5{x\xb7a\xd5\xc5-\xddz'\x15\xab\x08\xbf" +
"q\xca\xdb;\x9d\xee\x82\xe1*F\xd5\xfb\x9b\xaf7\x08" +
"/-\xc5(\xae\x80}Dz\x8aC\xcf0\xf4\xbb\xa1" +
"V\xa1\xab\xb5%\xa6\x8d>\xff\xb3p\xfd\x8d(\x8d\xb9" +
"O\x125W3\xa2\x8d\xa4\xea\xfb\x88\xa9y\x05\xadm" +
"\x88h\xf9\xa9\xffw\x89\xa9\xab\x14\xb0\xe6\xbf\x01D[" +
"_]t\x94\x98:_\x09\"e\xa4\xfeF\xc8\x01\x04" +
"Qv\x94\x0b\xf3\x1b@\x10\xc9/\"\x05%\x1a@\x01" +
"w_\xee[\xd4;\xe7\xddM\xc5\xa2Uy\xe7z5" +
"\xe2\xa4%_Y\xad\x98\xdfq\"\xbd\x83C\x9f\xcd\x10" +
"X\xce\x94\x94\xa6\xc7b-t;\x89k\x10\x8e\x84." +
"-\x1fK\xff\x99\xa6\xff\xfdR\x85\xf7p\xe8Gb\xdd" +
"\xfa\x98\x04\x1f\xe5\xd0\x9f\x8c\xa9\xf0\xe3r\x9b\x1c\xe1\xd0" +
"O7\x85M=u\x94H?\xcd\xa1\xbf\xd9R5\xf5" +
"ui\xf8\x1a\x87\xfe>\x83\"\\7\xe2\xa9\xd4\xdd\x96" +
"X[Ne\xd4\xb4\x85'%`j\xea\xe5\x95\x9c\xf5" +
"\x9ap\xab\x86-l\xf8k\x0d\xd3\xaa\xbb\x82Zc\xda" +
"\xc8/?\x1cS\x8e\xdf\x03\x00\x00\xff\xff#\xa3\xb8\x8f"
func init() {
schemas.Register(schema_db8274f9144abc7e,
0x84cb9536a2cf6d3c,
0x9b87b390babc2ccf,
0xa29a916d4ebdd894,
0xb70431c0dc014915,
0xc082ef6e0d42ed1d,
0xc793e50592935b4a,
0xcbd96442ae3bb01a,
0xdc3ed6801961e502,
0xe3e37d096a5b564e,
0xea58385c65416035,
0xf2c122394f447e8e,
0xf2c68e2547ec3866,
0xf41a0f001ad49e46)
}