cloudflared-mirror/tunnelrpc/tunnelrpc.capnp.go

// Code generated by capnpc-go. DO NOT EDIT.

package tunnelrpc

import (
	context "golang.org/x/net/context"
	strconv "strconv"
	capnp "zombiezen.com/go/capnproto2"
	text "zombiezen.com/go/capnproto2/encoding/text"
	schemas "zombiezen.com/go/capnproto2/schemas"
	server "zombiezen.com/go/capnproto2/server"
)

type Authentication struct{ capnp.Struct }

// Authentication_TypeID is the unique identifier for the type Authentication.
const Authentication_TypeID = 0xc082ef6e0d42ed1d

func NewAuthentication(s *capnp.Segment) (Authentication, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
	return Authentication{st}, err
}

func NewRootAuthentication(s *capnp.Segment) (Authentication, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
	return Authentication{st}, err
}

func ReadRootAuthentication(msg *capnp.Message) (Authentication, error) {
	root, err := msg.RootPtr()
	return Authentication{root.Struct()}, err
}

func (s Authentication) String() string {
	str, _ := text.Marshal(0xc082ef6e0d42ed1d, s.Struct)
	return str
}

func (s Authentication) Key() (string, error) {
	p, err := s.Struct.Ptr(0)
	return p.Text(), err
}

func (s Authentication) HasKey() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s Authentication) KeyBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return p.TextBytes(), err
}

func (s Authentication) SetKey(v string) error {
	return s.Struct.SetText(0, v)
}

func (s Authentication) Email() (string, error) {
	p, err := s.Struct.Ptr(1)
	return p.Text(), err
}

func (s Authentication) HasEmail() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s Authentication) EmailBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(1)
	return p.TextBytes(), err
}

func (s Authentication) SetEmail(v string) error {
	return s.Struct.SetText(1, v)
}

func (s Authentication) OriginCAKey() (string, error) {
	p, err := s.Struct.Ptr(2)
	return p.Text(), err
}

func (s Authentication) HasOriginCAKey() bool {
	p, err := s.Struct.Ptr(2)
	return p.IsValid() || err != nil
}

func (s Authentication) OriginCAKeyBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(2)
	return p.TextBytes(), err
}

func (s Authentication) SetOriginCAKey(v string) error {
	return s.Struct.SetText(2, v)
}

// Authentication_List is a list of Authentication.
type Authentication_List struct{ capnp.List }

// NewAuthentication creates a new list of Authentication.
func NewAuthentication_List(s *capnp.Segment, sz int32) (Authentication_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
	return Authentication_List{l}, err
}

func (s Authentication_List) At(i int) Authentication { return Authentication{s.List.Struct(i)} }

func (s Authentication_List) Set(i int, v Authentication) error { return s.List.SetStruct(i, v.Struct) }

func (s Authentication_List) String() string {
	str, _ := text.MarshalList(0xc082ef6e0d42ed1d, s.List)
	return str
}

// Authentication_Promise is a wrapper for a Authentication promised by a client call.
type Authentication_Promise struct{ *capnp.Pipeline }

func (p Authentication_Promise) Struct() (Authentication, error) {
	s, err := p.Pipeline.Struct()
	return Authentication{s}, err
}

type TunnelRegistration struct{ capnp.Struct }

// TunnelRegistration_TypeID is the unique identifier for the type TunnelRegistration.
const TunnelRegistration_TypeID = 0xf41a0f001ad49e46

func NewTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 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)
}

func (s TunnelRegistration_List) String() string {
	str, _ := text.MarshalList(0xf41a0f001ad49e46, s.List)
	return str
}

// TunnelRegistration_Promise is a wrapper for a TunnelRegistration promised by a client call.
type TunnelRegistration_Promise struct{ *capnp.Pipeline }

func (p TunnelRegistration_Promise) Struct() (TunnelRegistration, error) {
	s, err := p.Pipeline.Struct()
	return TunnelRegistration{s}, err
}

type RegistrationOptions struct{ capnp.Struct }

// RegistrationOptions_TypeID is the unique identifier for the type RegistrationOptions.
const RegistrationOptions_TypeID = 0xc793e50592935b4a

func NewRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 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)
}

func (s RegistrationOptions_List) String() string {
	str, _ := text.MarshalList(0xc793e50592935b4a, s.List)
	return str
}

// RegistrationOptions_Promise is a wrapper for a RegistrationOptions promised by a client call.
type RegistrationOptions_Promise struct{ *capnp.Pipeline }

func (p RegistrationOptions_Promise) Struct() (RegistrationOptions, error) {
	s, err := p.Pipeline.Struct()
	return RegistrationOptions{s}, err
}

type 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: 5})
	return CapnpConnectParameters{st}, err
}

func NewRootCapnpConnectParameters(s *capnp.Segment) (CapnpConnectParameters, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5})
	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)
}

func (s CapnpConnectParameters) Scope() (Scope, error) {
	p, err := s.Struct.Ptr(4)
	return Scope{Struct: p.Struct()}, err
}

func (s CapnpConnectParameters) HasScope() bool {
	p, err := s.Struct.Ptr(4)
	return p.IsValid() || err != nil
}

func (s CapnpConnectParameters) SetScope(v Scope) error {
	return s.Struct.SetPtr(4, v.Struct.ToPtr())
}

// NewScope sets the scope field to a newly
// allocated Scope struct, preferring placement in s's segment.
func (s CapnpConnectParameters) NewScope() (Scope, error) {
	ss, err := NewScope(s.Struct.Segment())
	if err != nil {
		return Scope{}, err
	}
	err = s.Struct.SetPtr(4, ss.Struct.ToPtr())
	return ss, err
}

// 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: 5}, 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)
}

func (s CapnpConnectParameters_List) String() string {
	str, _ := text.MarshalList(0xa78f37418c1077c8, s.List)
	return str
}

// 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
}

func (p CapnpConnectParameters_Promise) Scope() Scope_Promise {
	return Scope_Promise{Pipeline: p.Pipeline.GetPipeline(4)}
}

type Scope struct{ capnp.Struct }
type Scope_value Scope
type Scope_value_Which uint16

const (
	Scope_value_Which_systemName Scope_value_Which = 0
	Scope_value_Which_group      Scope_value_Which = 1
)

func (w Scope_value_Which) String() string {
	const s = "systemNamegroup"
	switch w {
	case Scope_value_Which_systemName:
		return s[0:10]
	case Scope_value_Which_group:
		return s[10:15]

	}
	return "Scope_value_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}

// Scope_TypeID is the unique identifier for the type Scope.
const Scope_TypeID = 0xc54a4a6fd4d87596

func NewScope(s *capnp.Segment) (Scope, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
	return Scope{st}, err
}

func NewRootScope(s *capnp.Segment) (Scope, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
	return Scope{st}, err
}

func ReadRootScope(msg *capnp.Message) (Scope, error) {
	root, err := msg.RootPtr()
	return Scope{root.Struct()}, err
}

func (s Scope) String() string {
	str, _ := text.Marshal(0xc54a4a6fd4d87596, s.Struct)
	return str
}

func (s Scope) Value() Scope_value { return Scope_value(s) }

func (s Scope_value) Which() Scope_value_Which {
	return Scope_value_Which(s.Struct.Uint16(0))
}
func (s Scope_value) SystemName() (string, error) {
	if s.Struct.Uint16(0) != 0 {
		panic("Which() != systemName")
	}
	p, err := s.Struct.Ptr(0)
	return p.Text(), err
}

func (s Scope_value) HasSystemName() bool {
	if s.Struct.Uint16(0) != 0 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s Scope_value) SystemNameBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return p.TextBytes(), err
}

func (s Scope_value) SetSystemName(v string) error {
	s.Struct.SetUint16(0, 0)
	return s.Struct.SetText(0, v)
}

func (s Scope_value) Group() (string, error) {
	if s.Struct.Uint16(0) != 1 {
		panic("Which() != group")
	}
	p, err := s.Struct.Ptr(0)
	return p.Text(), err
}

func (s Scope_value) HasGroup() bool {
	if s.Struct.Uint16(0) != 1 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s Scope_value) GroupBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return p.TextBytes(), err
}

func (s Scope_value) SetGroup(v string) error {
	s.Struct.SetUint16(0, 1)
	return s.Struct.SetText(0, v)
}

// Scope_List is a list of Scope.
type Scope_List struct{ capnp.List }

// NewScope creates a new list of Scope.
func NewScope_List(s *capnp.Segment, sz int32) (Scope_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
	return Scope_List{l}, err
}

func (s Scope_List) At(i int) Scope { return Scope{s.List.Struct(i)} }

func (s Scope_List) Set(i int, v Scope) error { return s.List.SetStruct(i, v.Struct) }

func (s Scope_List) String() string {
	str, _ := text.MarshalList(0xc54a4a6fd4d87596, s.List)
	return str
}

// Scope_Promise is a wrapper for a Scope promised by a client call.
type Scope_Promise struct{ *capnp.Pipeline }

func (p Scope_Promise) Struct() (Scope, error) {
	s, err := p.Pipeline.Struct()
	return Scope{s}, err
}

func (p Scope_Promise) Value() Scope_value_Promise { return Scope_value_Promise{p.Pipeline} }

// Scope_value_Promise is a wrapper for a Scope_value promised by a client call.
type Scope_value_Promise struct{ *capnp.Pipeline }

func (p Scope_value_Promise) Struct() (Scope_value, error) {
	s, err := p.Pipeline.Struct()
	return Scope_value{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: 3})
	return ConnectResult{st}, err
}

func NewRootConnectResult(s *capnp.Segment) (ConnectResult, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
	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
}

func (s ConnectResult) ClientConfig() (ClientConfig, error) {
	p, err := s.Struct.Ptr(2)
	return ClientConfig{Struct: p.Struct()}, err
}

func (s ConnectResult) HasClientConfig() bool {
	p, err := s.Struct.Ptr(2)
	return p.IsValid() || err != nil
}

func (s ConnectResult) SetClientConfig(v ClientConfig) error {
	return s.Struct.SetPtr(2, v.Struct.ToPtr())
}

// NewClientConfig sets the clientConfig field to a newly
// allocated ClientConfig struct, preferring placement in s's segment.
func (s ConnectResult) NewClientConfig() (ClientConfig, error) {
	ss, err := NewClientConfig(s.Struct.Segment())
	if err != nil {
		return ClientConfig{}, err
	}
	err = s.Struct.SetPtr(2, 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: 3}, 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) }

func (s ConnectResult_List) String() string {
	str, _ := text.MarshalList(0xff8d9848747c956a, s.List)
	return str
}

// 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)}
}

func (p ConnectResult_Promise) ClientConfig() ClientConfig_Promise {
	return ClientConfig_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
}

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) }

func (s ConnectError_List) String() string {
	str, _ := text.MarshalList(0xb14ce48f4e2abb0d, s.List)
	return str
}

// 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 ClientConfig struct{ capnp.Struct }

// ClientConfig_TypeID is the unique identifier for the type ClientConfig.
const ClientConfig_TypeID = 0xf0a143f1c95a678e

func NewClientConfig(s *capnp.Segment) (ClientConfig, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
	return ClientConfig{st}, err
}

func NewRootClientConfig(s *capnp.Segment) (ClientConfig, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
	return ClientConfig{st}, err
}

func ReadRootClientConfig(msg *capnp.Message) (ClientConfig, error) {
	root, err := msg.RootPtr()
	return ClientConfig{root.Struct()}, err
}

func (s ClientConfig) String() string {
	str, _ := text.Marshal(0xf0a143f1c95a678e, s.Struct)
	return str
}

func (s ClientConfig) Version() uint64 {
	return s.Struct.Uint64(0)
}

func (s ClientConfig) SetVersion(v uint64) {
	s.Struct.SetUint64(0, v)
}

func (s ClientConfig) SupervisorConfig() (SupervisorConfig, error) {
	p, err := s.Struct.Ptr(0)
	return SupervisorConfig{Struct: p.Struct()}, err
}

func (s ClientConfig) HasSupervisorConfig() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s ClientConfig) SetSupervisorConfig(v SupervisorConfig) error {
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewSupervisorConfig sets the supervisorConfig field to a newly
// allocated SupervisorConfig struct, preferring placement in s's segment.
func (s ClientConfig) NewSupervisorConfig() (SupervisorConfig, error) {
	ss, err := NewSupervisorConfig(s.Struct.Segment())
	if err != nil {
		return SupervisorConfig{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s ClientConfig) EdgeConnectionConfig() (EdgeConnectionConfig, error) {
	p, err := s.Struct.Ptr(1)
	return EdgeConnectionConfig{Struct: p.Struct()}, err
}

func (s ClientConfig) HasEdgeConnectionConfig() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s ClientConfig) SetEdgeConnectionConfig(v EdgeConnectionConfig) error {
	return s.Struct.SetPtr(1, v.Struct.ToPtr())
}

// NewEdgeConnectionConfig sets the edgeConnectionConfig field to a newly
// allocated EdgeConnectionConfig struct, preferring placement in s's segment.
func (s ClientConfig) NewEdgeConnectionConfig() (EdgeConnectionConfig, error) {
	ss, err := NewEdgeConnectionConfig(s.Struct.Segment())
	if err != nil {
		return EdgeConnectionConfig{}, err
	}
	err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
	return ss, err
}

func (s ClientConfig) DohProxyConfigs() (DoHProxyConfig_List, error) {
	p, err := s.Struct.Ptr(2)
	return DoHProxyConfig_List{List: p.List()}, err
}

func (s ClientConfig) HasDohProxyConfigs() bool {
	p, err := s.Struct.Ptr(2)
	return p.IsValid() || err != nil
}

func (s ClientConfig) SetDohProxyConfigs(v DoHProxyConfig_List) error {
	return s.Struct.SetPtr(2, v.List.ToPtr())
}

// NewDohProxyConfigs sets the dohProxyConfigs field to a newly
// allocated DoHProxyConfig_List, preferring placement in s's segment.
func (s ClientConfig) 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(2, l.List.ToPtr())
	return l, err
}

func (s ClientConfig) ReverseProxyConfigs() (ReverseProxyConfig_List, error) {
	p, err := s.Struct.Ptr(3)
	return ReverseProxyConfig_List{List: p.List()}, err
}

func (s ClientConfig) HasReverseProxyConfigs() bool {
	p, err := s.Struct.Ptr(3)
	return p.IsValid() || err != nil
}

func (s ClientConfig) SetReverseProxyConfigs(v ReverseProxyConfig_List) error {
	return s.Struct.SetPtr(3, v.List.ToPtr())
}

// NewReverseProxyConfigs sets the reverseProxyConfigs field to a newly
// allocated ReverseProxyConfig_List, preferring placement in s's segment.
func (s ClientConfig) 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(3, l.List.ToPtr())
	return l, err
}

// ClientConfig_List is a list of ClientConfig.
type ClientConfig_List struct{ capnp.List }

// NewClientConfig creates a new list of ClientConfig.
func NewClientConfig_List(s *capnp.Segment, sz int32) (ClientConfig_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}, sz)
	return ClientConfig_List{l}, err
}

func (s ClientConfig_List) At(i int) ClientConfig { return ClientConfig{s.List.Struct(i)} }

func (s ClientConfig_List) Set(i int, v ClientConfig) error { return s.List.SetStruct(i, v.Struct) }

func (s ClientConfig_List) String() string {
	str, _ := text.MarshalList(0xf0a143f1c95a678e, s.List)
	return str
}

// ClientConfig_Promise is a wrapper for a ClientConfig promised by a client call.
type ClientConfig_Promise struct{ *capnp.Pipeline }

func (p ClientConfig_Promise) Struct() (ClientConfig, error) {
	s, err := p.Pipeline.Struct()
	return ClientConfig{s}, err
}

func (p ClientConfig_Promise) SupervisorConfig() SupervisorConfig_Promise {
	return SupervisorConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p ClientConfig_Promise) EdgeConnectionConfig() EdgeConnectionConfig_Promise {
	return EdgeConnectionConfig_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
}

type SupervisorConfig struct{ capnp.Struct }

// SupervisorConfig_TypeID is the unique identifier for the type SupervisorConfig.
const SupervisorConfig_TypeID = 0xf7f49b3f779ae258

func NewSupervisorConfig(s *capnp.Segment) (SupervisorConfig, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0})
	return SupervisorConfig{st}, err
}

func NewRootSupervisorConfig(s *capnp.Segment) (SupervisorConfig, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0})
	return SupervisorConfig{st}, err
}

func ReadRootSupervisorConfig(msg *capnp.Message) (SupervisorConfig, error) {
	root, err := msg.RootPtr()
	return SupervisorConfig{root.Struct()}, err
}

func (s SupervisorConfig) String() string {
	str, _ := text.Marshal(0xf7f49b3f779ae258, s.Struct)
	return str
}

func (s SupervisorConfig) AutoUpdateFrequency() int64 {
	return int64(s.Struct.Uint64(0))
}

func (s SupervisorConfig) SetAutoUpdateFrequency(v int64) {
	s.Struct.SetUint64(0, uint64(v))
}

func (s SupervisorConfig) MetricsUpdateFrequency() int64 {
	return int64(s.Struct.Uint64(8))
}

func (s SupervisorConfig) SetMetricsUpdateFrequency(v int64) {
	s.Struct.SetUint64(8, uint64(v))
}

func (s SupervisorConfig) GracePeriod() int64 {
	return int64(s.Struct.Uint64(16))
}

func (s SupervisorConfig) SetGracePeriod(v int64) {
	s.Struct.SetUint64(16, uint64(v))
}

// SupervisorConfig_List is a list of SupervisorConfig.
type SupervisorConfig_List struct{ capnp.List }

// NewSupervisorConfig creates a new list of SupervisorConfig.
func NewSupervisorConfig_List(s *capnp.Segment, sz int32) (SupervisorConfig_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0}, sz)
	return SupervisorConfig_List{l}, err
}

func (s SupervisorConfig_List) At(i int) SupervisorConfig { return SupervisorConfig{s.List.Struct(i)} }

func (s SupervisorConfig_List) Set(i int, v SupervisorConfig) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s SupervisorConfig_List) String() string {
	str, _ := text.MarshalList(0xf7f49b3f779ae258, s.List)
	return str
}

// SupervisorConfig_Promise is a wrapper for a SupervisorConfig promised by a client call.
type SupervisorConfig_Promise struct{ *capnp.Pipeline }

func (p SupervisorConfig_Promise) Struct() (SupervisorConfig, error) {
	s, err := p.Pipeline.Struct()
	return SupervisorConfig{s}, err
}

type EdgeConnectionConfig struct{ capnp.Struct }

// EdgeConnectionConfig_TypeID is the unique identifier for the type EdgeConnectionConfig.
const EdgeConnectionConfig_TypeID = 0xc744e349009087aa

func NewEdgeConnectionConfig(s *capnp.Segment) (EdgeConnectionConfig, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1})
	return EdgeConnectionConfig{st}, err
}

func NewRootEdgeConnectionConfig(s *capnp.Segment) (EdgeConnectionConfig, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1})
	return EdgeConnectionConfig{st}, err
}

func ReadRootEdgeConnectionConfig(msg *capnp.Message) (EdgeConnectionConfig, error) {
	root, err := msg.RootPtr()
	return EdgeConnectionConfig{root.Struct()}, err
}

func (s EdgeConnectionConfig) String() string {
	str, _ := text.Marshal(0xc744e349009087aa, s.Struct)
	return str
}

func (s EdgeConnectionConfig) NumHAConnections() uint8 {
	return s.Struct.Uint8(0)
}

func (s EdgeConnectionConfig) SetNumHAConnections(v uint8) {
	s.Struct.SetUint8(0, v)
}

func (s EdgeConnectionConfig) HeartbeatInterval() int64 {
	return int64(s.Struct.Uint64(8))
}

func (s EdgeConnectionConfig) SetHeartbeatInterval(v int64) {
	s.Struct.SetUint64(8, uint64(v))
}

func (s EdgeConnectionConfig) Timeout() int64 {
	return int64(s.Struct.Uint64(16))
}

func (s EdgeConnectionConfig) SetTimeout(v int64) {
	s.Struct.SetUint64(16, uint64(v))
}

func (s EdgeConnectionConfig) MaxFailedHeartbeats() uint64 {
	return s.Struct.Uint64(24)
}

func (s EdgeConnectionConfig) SetMaxFailedHeartbeats(v uint64) {
	s.Struct.SetUint64(24, v)
}

func (s EdgeConnectionConfig) UserCredentialPath() (string, error) {
	p, err := s.Struct.Ptr(0)
	return p.Text(), err
}

func (s EdgeConnectionConfig) HasUserCredentialPath() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s EdgeConnectionConfig) UserCredentialPathBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return p.TextBytes(), err
}

func (s EdgeConnectionConfig) SetUserCredentialPath(v string) error {
	return s.Struct.SetText(0, v)
}

// EdgeConnectionConfig_List is a list of EdgeConnectionConfig.
type EdgeConnectionConfig_List struct{ capnp.List }

// NewEdgeConnectionConfig creates a new list of EdgeConnectionConfig.
func NewEdgeConnectionConfig_List(s *capnp.Segment, sz int32) (EdgeConnectionConfig_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 32, PointerCount: 1}, sz)
	return EdgeConnectionConfig_List{l}, err
}

func (s EdgeConnectionConfig_List) At(i int) EdgeConnectionConfig {
	return EdgeConnectionConfig{s.List.Struct(i)}
}

func (s EdgeConnectionConfig_List) Set(i int, v EdgeConnectionConfig) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s EdgeConnectionConfig_List) String() string {
	str, _ := text.MarshalList(0xc744e349009087aa, s.List)
	return str
}

// EdgeConnectionConfig_Promise is a wrapper for a EdgeConnectionConfig promised by a client call.
type EdgeConnectionConfig_Promise struct{ *capnp.Pipeline }

func (p EdgeConnectionConfig_Promise) Struct() (EdgeConnectionConfig, error) {
	s, err := p.Pipeline.Struct()
	return EdgeConnectionConfig{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_websocket  ReverseProxyConfig_origin_Which = 1
	ReverseProxyConfig_origin_Which_helloWorld ReverseProxyConfig_origin_Which = 2
)

func (w ReverseProxyConfig_origin_Which) String() string {
	const s = "httpwebsockethelloWorld"
	switch w {
	case ReverseProxyConfig_origin_Which_http:
		return s[0:4]
	case ReverseProxyConfig_origin_Which_websocket:
		return s[4:13]
	case ReverseProxyConfig_origin_Which_helloWorld:
		return s[13:23]

	}
	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) TunnelHostname() (string, error) {
	p, err := s.Struct.Ptr(0)
	return p.Text(), err
}

func (s ReverseProxyConfig) HasTunnelHostname() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s ReverseProxyConfig) TunnelHostnameBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return p.TextBytes(), err
}

func (s ReverseProxyConfig) SetTunnelHostname(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) {
	if s.Struct.Uint16(0) != 0 {
		panic("Which() != http")
	}
	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) Websocket() (WebSocketOriginConfig, error) {
	if s.Struct.Uint16(0) != 1 {
		panic("Which() != websocket")
	}
	p, err := s.Struct.Ptr(1)
	return WebSocketOriginConfig{Struct: p.Struct()}, err
}

func (s ReverseProxyConfig_origin) HasWebsocket() bool {
	if s.Struct.Uint16(0) != 1 {
		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, 1)
	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, 1)
	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) {
	if s.Struct.Uint16(0) != 2 {
		panic("Which() != helloWorld")
	}
	p, err := s.Struct.Ptr(1)
	return HelloWorldOriginConfig{Struct: p.Struct()}, err
}

func (s ReverseProxyConfig_origin) HasHelloWorld() bool {
	if s.Struct.Uint16(0) != 2 {
		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, 2)
	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, 2)
	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) 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)
}

func (s ReverseProxyConfig_List) String() string {
	str, _ := text.MarshalList(0xc766a92976e389c4, s.List)
	return str
}

// 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) 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 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: 8, PointerCount: 3})
	return WebSocketOriginConfig{st}, err
}

func NewRootWebSocketOriginConfig(s *capnp.Segment) (WebSocketOriginConfig, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
	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) UrlString() (string, error) {
	p, err := s.Struct.Ptr(0)
	return p.Text(), err
}

func (s WebSocketOriginConfig) HasUrlString() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s WebSocketOriginConfig) UrlStringBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return p.TextBytes(), err
}

func (s WebSocketOriginConfig) SetUrlString(v string) error {
	return s.Struct.SetText(0, v)
}

func (s WebSocketOriginConfig) TlsVerify() bool {
	return s.Struct.Bit(0)
}

func (s WebSocketOriginConfig) SetTlsVerify(v bool) {
	s.Struct.SetBit(0, v)
}

func (s WebSocketOriginConfig) OriginCAPool() (string, error) {
	p, err := s.Struct.Ptr(1)
	return p.Text(), err
}

func (s WebSocketOriginConfig) HasOriginCAPool() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s WebSocketOriginConfig) OriginCAPoolBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(1)
	return p.TextBytes(), err
}

func (s WebSocketOriginConfig) SetOriginCAPool(v string) error {
	return s.Struct.SetText(1, v)
}

func (s WebSocketOriginConfig) OriginServerName() (string, error) {
	p, err := s.Struct.Ptr(2)
	return p.Text(), err
}

func (s WebSocketOriginConfig) HasOriginServerName() bool {
	p, err := s.Struct.Ptr(2)
	return p.IsValid() || err != nil
}

func (s WebSocketOriginConfig) OriginServerNameBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(2)
	return p.TextBytes(), err
}

func (s WebSocketOriginConfig) SetOriginServerName(v string) error {
	return s.Struct.SetText(2, 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: 8, PointerCount: 3}, 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)
}

func (s WebSocketOriginConfig_List) String() string {
	str, _ := text.MarshalList(0xf9c895683ed9ac4c, s.List)
	return str
}

// 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: 56, PointerCount: 3})
	return HTTPOriginConfig{st}, err
}

func NewRootHTTPOriginConfig(s *capnp.Segment) (HTTPOriginConfig, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 56, 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) UrlString() (string, error) {
	p, err := s.Struct.Ptr(0)
	return p.Text(), err
}

func (s HTTPOriginConfig) HasUrlString() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s HTTPOriginConfig) UrlStringBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return p.TextBytes(), err
}

func (s HTTPOriginConfig) SetUrlString(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))
}

func (s HTTPOriginConfig) ProxyConnectionTimeout() int64 {
	return int64(s.Struct.Uint64(40))
}

func (s HTTPOriginConfig) SetProxyConnectionTimeout(v int64) {
	s.Struct.SetUint64(40, uint64(v))
}

func (s HTTPOriginConfig) ExpectContinueTimeout() int64 {
	return int64(s.Struct.Uint64(48))
}

func (s HTTPOriginConfig) SetExpectContinueTimeout(v int64) {
	s.Struct.SetUint64(48, uint64(v))
}

func (s HTTPOriginConfig) ChunkedEncoding() bool {
	return s.Struct.Bit(66)
}

func (s HTTPOriginConfig) SetChunkedEncoding(v bool) {
	s.Struct.SetBit(66, 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: 56, 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)
}

func (s HTTPOriginConfig_List) String() string {
	str, _ := text.MarshalList(0xe4a6a1bc139211b4, s.List)
	return str
}

// 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) }

func (s DoHProxyConfig_List) String() string {
	str, _ := text.MarshalList(0xb167b0bebe562cd0, s.List)
	return str
}

// 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)
}

func (s HelloWorldOriginConfig_List) String() string {
	str, _ := text.MarshalList(0x8891f360e47c30d3, s.List)
	return str
}

// 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) }

func (s Tag_List) String() string {
	str, _ := text.MarshalList(0xcbd96442ae3bb01a, s.List)
	return str
}

// Tag_Promise is a wrapper for a Tag promised by a client call.
type Tag_Promise struct{ *capnp.Pipeline }

func (p Tag_Promise) Struct() (Tag, error) {
	s, err := p.Pipeline.Struct()
	return Tag{s}, err
}

type ExistingTunnelPolicy uint16

// ExistingTunnelPolicy_TypeID is the unique identifier for the type ExistingTunnelPolicy.
const ExistingTunnelPolicy_TypeID = 0x84cb9536a2cf6d3c

// Values of ExistingTunnelPolicy.
const (
	ExistingTunnelPolicy_ignore     ExistingTunnelPolicy = 0
	ExistingTunnelPolicy_disconnect ExistingTunnelPolicy = 1
	ExistingTunnelPolicy_balance    ExistingTunnelPolicy = 2
)

// String returns the enum's constant name.
func (c ExistingTunnelPolicy) String() string {
	switch c {
	case ExistingTunnelPolicy_ignore:
		return "ignore"
	case ExistingTunnelPolicy_disconnect:
		return "disconnect"
	case ExistingTunnelPolicy_balance:
		return "balance"

	default:
		return ""
	}
}

// ExistingTunnelPolicyFromString returns the enum value with a name,
// or the zero value if there's no such value.
func ExistingTunnelPolicyFromString(c string) ExistingTunnelPolicy {
	switch c {
	case "ignore":
		return ExistingTunnelPolicy_ignore
	case "disconnect":
		return ExistingTunnelPolicy_disconnect
	case "balance":
		return ExistingTunnelPolicy_balance

	default:
		return 0
	}
}

type ExistingTunnelPolicy_List struct{ capnp.List }

func NewExistingTunnelPolicy_List(s *capnp.Segment, sz int32) (ExistingTunnelPolicy_List, error) {
	l, err := capnp.NewUInt16List(s, sz)
	return ExistingTunnelPolicy_List{l.List}, err
}

func (l ExistingTunnelPolicy_List) At(i int) ExistingTunnelPolicy {
	ul := capnp.UInt16List{List: l.List}
	return ExistingTunnelPolicy(ul.At(i))
}

func (l ExistingTunnelPolicy_List) Set(i int, v ExistingTunnelPolicy) {
	ul := capnp.UInt16List{List: l.List}
	ul.Set(i, uint16(v))
}

type ServerInfo struct{ capnp.Struct }

// ServerInfo_TypeID is the unique identifier for the type ServerInfo.
const ServerInfo_TypeID = 0xf2c68e2547ec3866

func NewServerInfo(s *capnp.Segment) (ServerInfo, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return ServerInfo{st}, err
}

func NewRootServerInfo(s *capnp.Segment) (ServerInfo, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return ServerInfo{st}, err
}

func ReadRootServerInfo(msg *capnp.Message) (ServerInfo, error) {
	root, err := msg.RootPtr()
	return ServerInfo{root.Struct()}, err
}

func (s ServerInfo) String() string {
	str, _ := text.Marshal(0xf2c68e2547ec3866, s.Struct)
	return str
}

func (s ServerInfo) LocationName() (string, error) {
	p, err := s.Struct.Ptr(0)
	return p.Text(), err
}

func (s ServerInfo) HasLocationName() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s ServerInfo) LocationNameBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return p.TextBytes(), err
}

func (s ServerInfo) SetLocationName(v string) error {
	return s.Struct.SetText(0, v)
}

// ServerInfo_List is a list of ServerInfo.
type ServerInfo_List struct{ capnp.List }

// NewServerInfo creates a new list of ServerInfo.
func NewServerInfo_List(s *capnp.Segment, sz int32) (ServerInfo_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return ServerInfo_List{l}, err
}

func (s ServerInfo_List) At(i int) ServerInfo { return ServerInfo{s.List.Struct(i)} }

func (s ServerInfo_List) Set(i int, v ServerInfo) error { return s.List.SetStruct(i, v.Struct) }

func (s ServerInfo_List) String() string {
	str, _ := text.MarshalList(0xf2c68e2547ec3866, s.List)
	return str
}

// ServerInfo_Promise is a wrapper for a ServerInfo promised by a client call.
type ServerInfo_Promise struct{ *capnp.Pipeline }

func (p ServerInfo_Promise) Struct() (ServerInfo, error) {
	s, err := p.Pipeline.Struct()
	return ServerInfo{s}, err
}

type 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) FailedConfigs() (FailedConfig_List, error) {
	p, err := s.Struct.Ptr(0)
	return FailedConfig_List{List: p.List()}, err
}

func (s UseConfigurationResult) HasFailedConfigs() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s UseConfigurationResult) SetFailedConfigs(v FailedConfig_List) error {
	return s.Struct.SetPtr(0, v.List.ToPtr())
}

// NewFailedConfigs sets the failedConfigs field to a newly
// allocated FailedConfig_List, preferring placement in s's segment.
func (s UseConfigurationResult) NewFailedConfigs(n int32) (FailedConfig_List, error) {
	l, err := NewFailedConfig_List(s.Struct.Segment(), n)
	if err != nil {
		return FailedConfig_List{}, err
	}
	err = s.Struct.SetPtr(0, l.List.ToPtr())
	return l, err
}

// 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)
}

func (s UseConfigurationResult_List) String() string {
	str, _ := text.MarshalList(0xd58a254e7a792b87, s.List)
	return str
}

// 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 FailedConfig struct{ capnp.Struct }
type FailedConfig_config FailedConfig
type FailedConfig_config_Which uint16

const (
	FailedConfig_config_Which_supervisor     FailedConfig_config_Which = 0
	FailedConfig_config_Which_edgeConnection FailedConfig_config_Which = 1
	FailedConfig_config_Which_doh            FailedConfig_config_Which = 2
	FailedConfig_config_Which_reverseProxy   FailedConfig_config_Which = 3
)

func (w FailedConfig_config_Which) String() string {
	const s = "supervisoredgeConnectiondohreverseProxy"
	switch w {
	case FailedConfig_config_Which_supervisor:
		return s[0:10]
	case FailedConfig_config_Which_edgeConnection:
		return s[10:24]
	case FailedConfig_config_Which_doh:
		return s[24:27]
	case FailedConfig_config_Which_reverseProxy:
		return s[27:39]

	}
	return "FailedConfig_config_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}

// FailedConfig_TypeID is the unique identifier for the type FailedConfig.
const FailedConfig_TypeID = 0xea20b390b257d1a5

func NewFailedConfig(s *capnp.Segment) (FailedConfig, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
	return FailedConfig{st}, err
}

func NewRootFailedConfig(s *capnp.Segment) (FailedConfig, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
	return FailedConfig{st}, err
}

func ReadRootFailedConfig(msg *capnp.Message) (FailedConfig, error) {
	root, err := msg.RootPtr()
	return FailedConfig{root.Struct()}, err
}

func (s FailedConfig) String() string {
	str, _ := text.Marshal(0xea20b390b257d1a5, s.Struct)
	return str
}

func (s FailedConfig) Config() FailedConfig_config { return FailedConfig_config(s) }

func (s FailedConfig_config) Which() FailedConfig_config_Which {
	return FailedConfig_config_Which(s.Struct.Uint16(0))
}
func (s FailedConfig_config) Supervisor() (SupervisorConfig, error) {
	if s.Struct.Uint16(0) != 0 {
		panic("Which() != supervisor")
	}
	p, err := s.Struct.Ptr(0)
	return SupervisorConfig{Struct: p.Struct()}, err
}

func (s FailedConfig_config) HasSupervisor() bool {
	if s.Struct.Uint16(0) != 0 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s FailedConfig_config) SetSupervisor(v SupervisorConfig) error {
	s.Struct.SetUint16(0, 0)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewSupervisor sets the supervisor field to a newly
// allocated SupervisorConfig struct, preferring placement in s's segment.
func (s FailedConfig_config) NewSupervisor() (SupervisorConfig, error) {
	s.Struct.SetUint16(0, 0)
	ss, err := NewSupervisorConfig(s.Struct.Segment())
	if err != nil {
		return SupervisorConfig{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s FailedConfig_config) EdgeConnection() (EdgeConnectionConfig, error) {
	if s.Struct.Uint16(0) != 1 {
		panic("Which() != edgeConnection")
	}
	p, err := s.Struct.Ptr(0)
	return EdgeConnectionConfig{Struct: p.Struct()}, err
}

func (s FailedConfig_config) HasEdgeConnection() bool {
	if s.Struct.Uint16(0) != 1 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s FailedConfig_config) SetEdgeConnection(v EdgeConnectionConfig) error {
	s.Struct.SetUint16(0, 1)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewEdgeConnection sets the edgeConnection field to a newly
// allocated EdgeConnectionConfig struct, preferring placement in s's segment.
func (s FailedConfig_config) NewEdgeConnection() (EdgeConnectionConfig, error) {
	s.Struct.SetUint16(0, 1)
	ss, err := NewEdgeConnectionConfig(s.Struct.Segment())
	if err != nil {
		return EdgeConnectionConfig{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s FailedConfig_config) Doh() (DoHProxyConfig, error) {
	if s.Struct.Uint16(0) != 2 {
		panic("Which() != doh")
	}
	p, err := s.Struct.Ptr(0)
	return DoHProxyConfig{Struct: p.Struct()}, err
}

func (s FailedConfig_config) HasDoh() bool {
	if s.Struct.Uint16(0) != 2 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s FailedConfig_config) SetDoh(v DoHProxyConfig) error {
	s.Struct.SetUint16(0, 2)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewDoh sets the doh field to a newly
// allocated DoHProxyConfig struct, preferring placement in s's segment.
func (s FailedConfig_config) NewDoh() (DoHProxyConfig, error) {
	s.Struct.SetUint16(0, 2)
	ss, err := NewDoHProxyConfig(s.Struct.Segment())
	if err != nil {
		return DoHProxyConfig{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s FailedConfig_config) ReverseProxy() (ReverseProxyConfig, error) {
	if s.Struct.Uint16(0) != 3 {
		panic("Which() != reverseProxy")
	}
	p, err := s.Struct.Ptr(0)
	return ReverseProxyConfig{Struct: p.Struct()}, err
}

func (s FailedConfig_config) HasReverseProxy() bool {
	if s.Struct.Uint16(0) != 3 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s FailedConfig_config) SetReverseProxy(v ReverseProxyConfig) error {
	s.Struct.SetUint16(0, 3)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewReverseProxy sets the reverseProxy field to a newly
// allocated ReverseProxyConfig struct, preferring placement in s's segment.
func (s FailedConfig_config) NewReverseProxy() (ReverseProxyConfig, error) {
	s.Struct.SetUint16(0, 3)
	ss, err := NewReverseProxyConfig(s.Struct.Segment())
	if err != nil {
		return ReverseProxyConfig{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s FailedConfig) Reason() (string, error) {
	p, err := s.Struct.Ptr(1)
	return p.Text(), err
}

func (s FailedConfig) HasReason() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s FailedConfig) ReasonBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(1)
	return p.TextBytes(), err
}

func (s FailedConfig) SetReason(v string) error {
	return s.Struct.SetText(1, v)
}

// FailedConfig_List is a list of FailedConfig.
type FailedConfig_List struct{ capnp.List }

// NewFailedConfig creates a new list of FailedConfig.
func NewFailedConfig_List(s *capnp.Segment, sz int32) (FailedConfig_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
	return FailedConfig_List{l}, err
}

func (s FailedConfig_List) At(i int) FailedConfig { return FailedConfig{s.List.Struct(i)} }

func (s FailedConfig_List) Set(i int, v FailedConfig) error { return s.List.SetStruct(i, v.Struct) }

func (s FailedConfig_List) String() string {
	str, _ := text.MarshalList(0xea20b390b257d1a5, s.List)
	return str
}

// FailedConfig_Promise is a wrapper for a FailedConfig promised by a client call.
type FailedConfig_Promise struct{ *capnp.Pipeline }

func (p FailedConfig_Promise) Struct() (FailedConfig, error) {
	s, err := p.Pipeline.Struct()
	return FailedConfig{s}, err
}

func (p FailedConfig_Promise) Config() FailedConfig_config_Promise {
	return FailedConfig_config_Promise{p.Pipeline}
}

// FailedConfig_config_Promise is a wrapper for a FailedConfig_config promised by a client call.
type FailedConfig_config_Promise struct{ *capnp.Pipeline }

func (p FailedConfig_config_Promise) Struct() (FailedConfig_config, error) {
	s, err := p.Pipeline.Struct()
	return FailedConfig_config{s}, err
}

func (p FailedConfig_config_Promise) Supervisor() SupervisorConfig_Promise {
	return SupervisorConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p FailedConfig_config_Promise) EdgeConnection() EdgeConnectionConfig_Promise {
	return EdgeConnectionConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p FailedConfig_config_Promise) Doh() DoHProxyConfig_Promise {
	return DoHProxyConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p FailedConfig_config_Promise) ReverseProxy() ReverseProxyConfig_Promise {
	return ReverseProxyConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

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)
}

func (s TunnelServer_registerTunnel_Params_List) String() string {
	str, _ := text.MarshalList(0xb70431c0dc014915, s.List)
	return str
}

// TunnelServer_registerTunnel_Params_Promise is a wrapper for a TunnelServer_registerTunnel_Params promised by a client call.
type TunnelServer_registerTunnel_Params_Promise struct{ *capnp.Pipeline }

func (p TunnelServer_registerTunnel_Params_Promise) Struct() (TunnelServer_registerTunnel_Params, error) {
	s, err := p.Pipeline.Struct()
	return TunnelServer_registerTunnel_Params{s}, err
}

func (p TunnelServer_registerTunnel_Params_Promise) Options() RegistrationOptions_Promise {
	return RegistrationOptions_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
}

type TunnelServer_registerTunnel_Results struct{ capnp.Struct }

// TunnelServer_registerTunnel_Results_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Results.
const TunnelServer_registerTunnel_Results_TypeID = 0xf2c122394f447e8e

func NewTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return TunnelServer_registerTunnel_Results{st}, err
}

func NewRootTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return TunnelServer_registerTunnel_Results{st}, err
}

func ReadRootTunnelServer_registerTunnel_Results(msg *capnp.Message) (TunnelServer_registerTunnel_Results, error) {
	root, err := msg.RootPtr()
	return TunnelServer_registerTunnel_Results{root.Struct()}, err
}

func (s TunnelServer_registerTunnel_Results) String() string {
	str, _ := text.Marshal(0xf2c122394f447e8e, s.Struct)
	return str
}

func (s TunnelServer_registerTunnel_Results) Result() (TunnelRegistration, error) {
	p, err := s.Struct.Ptr(0)
	return TunnelRegistration{Struct: p.Struct()}, err
}

func (s TunnelServer_registerTunnel_Results) HasResult() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s TunnelServer_registerTunnel_Results) SetResult(v TunnelRegistration) error {
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewResult sets the result field to a newly
// allocated TunnelRegistration struct, preferring placement in s's segment.
func (s TunnelServer_registerTunnel_Results) NewResult() (TunnelRegistration, error) {
	ss, err := NewTunnelRegistration(s.Struct.Segment())
	if err != nil {
		return TunnelRegistration{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

// TunnelServer_registerTunnel_Results_List is a list of TunnelServer_registerTunnel_Results.
type TunnelServer_registerTunnel_Results_List struct{ capnp.List }

// NewTunnelServer_registerTunnel_Results creates a new list of TunnelServer_registerTunnel_Results.
func NewTunnelServer_registerTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Results_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return TunnelServer_registerTunnel_Results_List{l}, err
}

func (s TunnelServer_registerTunnel_Results_List) At(i int) TunnelServer_registerTunnel_Results {
	return TunnelServer_registerTunnel_Results{s.List.Struct(i)}
}

func (s TunnelServer_registerTunnel_Results_List) Set(i int, v TunnelServer_registerTunnel_Results) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s TunnelServer_registerTunnel_Results_List) String() string {
	str, _ := text.MarshalList(0xf2c122394f447e8e, s.List)
	return str
}

// TunnelServer_registerTunnel_Results_Promise is a wrapper for a TunnelServer_registerTunnel_Results promised by a client call.
type TunnelServer_registerTunnel_Results_Promise struct{ *capnp.Pipeline }

func (p TunnelServer_registerTunnel_Results_Promise) Struct() (TunnelServer_registerTunnel_Results, error) {
	s, err := p.Pipeline.Struct()
	return TunnelServer_registerTunnel_Results{s}, err
}

func (p TunnelServer_registerTunnel_Results_Promise) Result() TunnelRegistration_Promise {
	return TunnelRegistration_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

type TunnelServer_getServerInfo_Params struct{ capnp.Struct }

// TunnelServer_getServerInfo_Params_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Params.
const TunnelServer_getServerInfo_Params_TypeID = 0xdc3ed6801961e502

func NewTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
	return TunnelServer_getServerInfo_Params{st}, err
}

func NewRootTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
	return TunnelServer_getServerInfo_Params{st}, err
}

func ReadRootTunnelServer_getServerInfo_Params(msg *capnp.Message) (TunnelServer_getServerInfo_Params, error) {
	root, err := msg.RootPtr()
	return TunnelServer_getServerInfo_Params{root.Struct()}, err
}

func (s TunnelServer_getServerInfo_Params) String() string {
	str, _ := text.Marshal(0xdc3ed6801961e502, s.Struct)
	return str
}

// TunnelServer_getServerInfo_Params_List is a list of TunnelServer_getServerInfo_Params.
type TunnelServer_getServerInfo_Params_List struct{ capnp.List }

// NewTunnelServer_getServerInfo_Params creates a new list of TunnelServer_getServerInfo_Params.
func NewTunnelServer_getServerInfo_Params_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Params_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
	return TunnelServer_getServerInfo_Params_List{l}, err
}

func (s TunnelServer_getServerInfo_Params_List) At(i int) TunnelServer_getServerInfo_Params {
	return TunnelServer_getServerInfo_Params{s.List.Struct(i)}
}

func (s TunnelServer_getServerInfo_Params_List) Set(i int, v TunnelServer_getServerInfo_Params) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s TunnelServer_getServerInfo_Params_List) String() string {
	str, _ := text.MarshalList(0xdc3ed6801961e502, s.List)
	return str
}

// TunnelServer_getServerInfo_Params_Promise is a wrapper for a TunnelServer_getServerInfo_Params promised by a client call.
type TunnelServer_getServerInfo_Params_Promise struct{ *capnp.Pipeline }

func (p TunnelServer_getServerInfo_Params_Promise) Struct() (TunnelServer_getServerInfo_Params, error) {
	s, err := p.Pipeline.Struct()
	return TunnelServer_getServerInfo_Params{s}, err
}

type TunnelServer_getServerInfo_Results struct{ capnp.Struct }

// TunnelServer_getServerInfo_Results_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Results.
const TunnelServer_getServerInfo_Results_TypeID = 0xe3e37d096a5b564e

func NewTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return TunnelServer_getServerInfo_Results{st}, err
}

func NewRootTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return TunnelServer_getServerInfo_Results{st}, err
}

func ReadRootTunnelServer_getServerInfo_Results(msg *capnp.Message) (TunnelServer_getServerInfo_Results, error) {
	root, err := msg.RootPtr()
	return TunnelServer_getServerInfo_Results{root.Struct()}, err
}

func (s TunnelServer_getServerInfo_Results) String() string {
	str, _ := text.Marshal(0xe3e37d096a5b564e, s.Struct)
	return str
}

func (s TunnelServer_getServerInfo_Results) Result() (ServerInfo, error) {
	p, err := s.Struct.Ptr(0)
	return ServerInfo{Struct: p.Struct()}, err
}

func (s TunnelServer_getServerInfo_Results) HasResult() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s TunnelServer_getServerInfo_Results) SetResult(v ServerInfo) error {
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewResult sets the result field to a newly
// allocated ServerInfo struct, preferring placement in s's segment.
func (s TunnelServer_getServerInfo_Results) NewResult() (ServerInfo, error) {
	ss, err := NewServerInfo(s.Struct.Segment())
	if err != nil {
		return ServerInfo{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

// TunnelServer_getServerInfo_Results_List is a list of TunnelServer_getServerInfo_Results.
type TunnelServer_getServerInfo_Results_List struct{ capnp.List }

// NewTunnelServer_getServerInfo_Results creates a new list of TunnelServer_getServerInfo_Results.
func NewTunnelServer_getServerInfo_Results_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Results_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return TunnelServer_getServerInfo_Results_List{l}, err
}

func (s TunnelServer_getServerInfo_Results_List) At(i int) TunnelServer_getServerInfo_Results {
	return TunnelServer_getServerInfo_Results{s.List.Struct(i)}
}

func (s TunnelServer_getServerInfo_Results_List) Set(i int, v TunnelServer_getServerInfo_Results) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s TunnelServer_getServerInfo_Results_List) String() string {
	str, _ := text.MarshalList(0xe3e37d096a5b564e, s.List)
	return str
}

// TunnelServer_getServerInfo_Results_Promise is a wrapper for a TunnelServer_getServerInfo_Results promised by a client call.
type TunnelServer_getServerInfo_Results_Promise struct{ *capnp.Pipeline }

func (p TunnelServer_getServerInfo_Results_Promise) Struct() (TunnelServer_getServerInfo_Results, error) {
	s, err := p.Pipeline.Struct()
	return TunnelServer_getServerInfo_Results{s}, err
}

func (p TunnelServer_getServerInfo_Results_Promise) Result() ServerInfo_Promise {
	return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

type TunnelServer_unregisterTunnel_Params struct{ capnp.Struct }

// TunnelServer_unregisterTunnel_Params_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Params.
const TunnelServer_unregisterTunnel_Params_TypeID = 0x9b87b390babc2ccf

func NewTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
	return TunnelServer_unregisterTunnel_Params{st}, err
}

func NewRootTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
	return TunnelServer_unregisterTunnel_Params{st}, err
}

func ReadRootTunnelServer_unregisterTunnel_Params(msg *capnp.Message) (TunnelServer_unregisterTunnel_Params, error) {
	root, err := msg.RootPtr()
	return TunnelServer_unregisterTunnel_Params{root.Struct()}, err
}

func (s TunnelServer_unregisterTunnel_Params) String() string {
	str, _ := text.Marshal(0x9b87b390babc2ccf, s.Struct)
	return str
}

func (s TunnelServer_unregisterTunnel_Params) GracePeriodNanoSec() int64 {
	return int64(s.Struct.Uint64(0))
}

func (s TunnelServer_unregisterTunnel_Params) SetGracePeriodNanoSec(v int64) {
	s.Struct.SetUint64(0, uint64(v))
}

// TunnelServer_unregisterTunnel_Params_List is a list of TunnelServer_unregisterTunnel_Params.
type TunnelServer_unregisterTunnel_Params_List struct{ capnp.List }

// NewTunnelServer_unregisterTunnel_Params creates a new list of TunnelServer_unregisterTunnel_Params.
func NewTunnelServer_unregisterTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Params_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz)
	return TunnelServer_unregisterTunnel_Params_List{l}, err
}

func (s TunnelServer_unregisterTunnel_Params_List) At(i int) TunnelServer_unregisterTunnel_Params {
	return TunnelServer_unregisterTunnel_Params{s.List.Struct(i)}
}

func (s TunnelServer_unregisterTunnel_Params_List) Set(i int, v TunnelServer_unregisterTunnel_Params) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s TunnelServer_unregisterTunnel_Params_List) String() string {
	str, _ := text.MarshalList(0x9b87b390babc2ccf, s.List)
	return str
}

// TunnelServer_unregisterTunnel_Params_Promise is a wrapper for a TunnelServer_unregisterTunnel_Params promised by a client call.
type TunnelServer_unregisterTunnel_Params_Promise struct{ *capnp.Pipeline }

func (p TunnelServer_unregisterTunnel_Params_Promise) Struct() (TunnelServer_unregisterTunnel_Params, error) {
	s, err := p.Pipeline.Struct()
	return TunnelServer_unregisterTunnel_Params{s}, err
}

type TunnelServer_unregisterTunnel_Results struct{ capnp.Struct }

// TunnelServer_unregisterTunnel_Results_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Results.
const TunnelServer_unregisterTunnel_Results_TypeID = 0xa29a916d4ebdd894

func NewTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
	return TunnelServer_unregisterTunnel_Results{st}, err
}

func NewRootTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
	return TunnelServer_unregisterTunnel_Results{st}, err
}

func ReadRootTunnelServer_unregisterTunnel_Results(msg *capnp.Message) (TunnelServer_unregisterTunnel_Results, error) {
	root, err := msg.RootPtr()
	return TunnelServer_unregisterTunnel_Results{root.Struct()}, err
}

func (s TunnelServer_unregisterTunnel_Results) String() string {
	str, _ := text.Marshal(0xa29a916d4ebdd894, s.Struct)
	return str
}

// TunnelServer_unregisterTunnel_Results_List is a list of TunnelServer_unregisterTunnel_Results.
type TunnelServer_unregisterTunnel_Results_List struct{ capnp.List }

// NewTunnelServer_unregisterTunnel_Results creates a new list of TunnelServer_unregisterTunnel_Results.
func NewTunnelServer_unregisterTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Results_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
	return TunnelServer_unregisterTunnel_Results_List{l}, err
}

func (s TunnelServer_unregisterTunnel_Results_List) At(i int) TunnelServer_unregisterTunnel_Results {
	return TunnelServer_unregisterTunnel_Results{s.List.Struct(i)}
}

func (s TunnelServer_unregisterTunnel_Results_List) Set(i int, v TunnelServer_unregisterTunnel_Results) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s TunnelServer_unregisterTunnel_Results_List) String() string {
	str, _ := text.MarshalList(0xa29a916d4ebdd894, s.List)
	return str
}

// TunnelServer_unregisterTunnel_Results_Promise is a wrapper for a TunnelServer_unregisterTunnel_Results promised by a client call.
type TunnelServer_unregisterTunnel_Results_Promise struct{ *capnp.Pipeline }

func (p TunnelServer_unregisterTunnel_Results_Promise) Struct() (TunnelServer_unregisterTunnel_Results, error) {
	s, err := p.Pipeline.Struct()
	return TunnelServer_unregisterTunnel_Results{s}, err
}

type TunnelServer_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)
}

func (s TunnelServer_connect_Params_List) String() string {
	str, _ := text.MarshalList(0xa766b24d4fe5da35, s.List)
	return str
}

// 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)
}

func (s TunnelServer_connect_Results_List) String() string {
	str, _ := text.MarshalList(0xfeac5c8f4899ef7c, s.List)
	return str
}

// 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 ClientService struct{ Client capnp.Client }

// ClientService_TypeID is the unique identifier for the type ClientService.
const ClientService_TypeID = 0xf143a395ed8b3133

func (c ClientService) UseConfiguration(ctx context.Context, params func(ClientService_useConfiguration_Params) error, opts ...capnp.CallOption) ClientService_useConfiguration_Results_Promise {
	if c.Client == nil {
		return ClientService_useConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
	}
	call := &capnp.Call{
		Ctx: ctx,
		Method: capnp.Method{
			InterfaceID:   0xf143a395ed8b3133,
			MethodID:      0,
			InterfaceName: "tunnelrpc/tunnelrpc.capnp:ClientService",
			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(ClientService_useConfiguration_Params{Struct: s}) }
	}
	return ClientService_useConfiguration_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
}

type ClientService_Server interface {
	UseConfiguration(ClientService_useConfiguration) error
}

func ClientService_ServerToClient(s ClientService_Server) ClientService {
	c, _ := s.(server.Closer)
	return ClientService{Client: server.New(ClientService_Methods(nil, s), c)}
}

func ClientService_Methods(methods []server.Method, s ClientService_Server) []server.Method {
	if cap(methods) == 0 {
		methods = make([]server.Method, 0, 1)
	}

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xf143a395ed8b3133,
			MethodID:      0,
			InterfaceName: "tunnelrpc/tunnelrpc.capnp:ClientService",
			MethodName:    "useConfiguration",
		},
		Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
			call := ClientService_useConfiguration{c, opts, ClientService_useConfiguration_Params{Struct: p}, ClientService_useConfiguration_Results{Struct: r}}
			return s.UseConfiguration(call)
		},
		ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
	})

	return methods
}

// ClientService_useConfiguration holds the arguments for a server call to ClientService.useConfiguration.
type ClientService_useConfiguration struct {
	Ctx     context.Context
	Options capnp.CallOptions
	Params  ClientService_useConfiguration_Params
	Results ClientService_useConfiguration_Results
}

type ClientService_useConfiguration_Params struct{ capnp.Struct }

// ClientService_useConfiguration_Params_TypeID is the unique identifier for the type ClientService_useConfiguration_Params.
const ClientService_useConfiguration_Params_TypeID = 0xb9d4ef45c2b5fc5b

func NewClientService_useConfiguration_Params(s *capnp.Segment) (ClientService_useConfiguration_Params, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return ClientService_useConfiguration_Params{st}, err
}

func NewRootClientService_useConfiguration_Params(s *capnp.Segment) (ClientService_useConfiguration_Params, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return ClientService_useConfiguration_Params{st}, err
}

func ReadRootClientService_useConfiguration_Params(msg *capnp.Message) (ClientService_useConfiguration_Params, error) {
	root, err := msg.RootPtr()
	return ClientService_useConfiguration_Params{root.Struct()}, err
}

func (s ClientService_useConfiguration_Params) String() string {
	str, _ := text.Marshal(0xb9d4ef45c2b5fc5b, s.Struct)
	return str
}

func (s ClientService_useConfiguration_Params) ClientServiceConfig() (ClientConfig, error) {
	p, err := s.Struct.Ptr(0)
	return ClientConfig{Struct: p.Struct()}, err
}

func (s ClientService_useConfiguration_Params) HasClientServiceConfig() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s ClientService_useConfiguration_Params) SetClientServiceConfig(v ClientConfig) error {
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewClientServiceConfig sets the clientServiceConfig field to a newly
// allocated ClientConfig struct, preferring placement in s's segment.
func (s ClientService_useConfiguration_Params) NewClientServiceConfig() (ClientConfig, error) {
	ss, err := NewClientConfig(s.Struct.Segment())
	if err != nil {
		return ClientConfig{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

// ClientService_useConfiguration_Params_List is a list of ClientService_useConfiguration_Params.
type ClientService_useConfiguration_Params_List struct{ capnp.List }

// NewClientService_useConfiguration_Params creates a new list of ClientService_useConfiguration_Params.
func NewClientService_useConfiguration_Params_List(s *capnp.Segment, sz int32) (ClientService_useConfiguration_Params_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return ClientService_useConfiguration_Params_List{l}, err
}

func (s ClientService_useConfiguration_Params_List) At(i int) ClientService_useConfiguration_Params {
	return ClientService_useConfiguration_Params{s.List.Struct(i)}
}

func (s ClientService_useConfiguration_Params_List) Set(i int, v ClientService_useConfiguration_Params) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s ClientService_useConfiguration_Params_List) String() string {
	str, _ := text.MarshalList(0xb9d4ef45c2b5fc5b, s.List)
	return str
}

// ClientService_useConfiguration_Params_Promise is a wrapper for a ClientService_useConfiguration_Params promised by a client call.
type ClientService_useConfiguration_Params_Promise struct{ *capnp.Pipeline }

func (p ClientService_useConfiguration_Params_Promise) Struct() (ClientService_useConfiguration_Params, error) {
	s, err := p.Pipeline.Struct()
	return ClientService_useConfiguration_Params{s}, err
}

func (p ClientService_useConfiguration_Params_Promise) ClientServiceConfig() ClientConfig_Promise {
	return ClientConfig_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

type ClientService_useConfiguration_Results struct{ capnp.Struct }

// ClientService_useConfiguration_Results_TypeID is the unique identifier for the type ClientService_useConfiguration_Results.
const ClientService_useConfiguration_Results_TypeID = 0x91f7a001ca145b9d

func NewClientService_useConfiguration_Results(s *capnp.Segment) (ClientService_useConfiguration_Results, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return ClientService_useConfiguration_Results{st}, err
}

func NewRootClientService_useConfiguration_Results(s *capnp.Segment) (ClientService_useConfiguration_Results, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return ClientService_useConfiguration_Results{st}, err
}

func ReadRootClientService_useConfiguration_Results(msg *capnp.Message) (ClientService_useConfiguration_Results, error) {
	root, err := msg.RootPtr()
	return ClientService_useConfiguration_Results{root.Struct()}, err
}

func (s ClientService_useConfiguration_Results) String() string {
	str, _ := text.Marshal(0x91f7a001ca145b9d, s.Struct)
	return str
}

func (s ClientService_useConfiguration_Results) Result() (UseConfigurationResult, error) {
	p, err := s.Struct.Ptr(0)
	return UseConfigurationResult{Struct: p.Struct()}, err
}

func (s ClientService_useConfiguration_Results) HasResult() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s ClientService_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 ClientService_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
}

// ClientService_useConfiguration_Results_List is a list of ClientService_useConfiguration_Results.
type ClientService_useConfiguration_Results_List struct{ capnp.List }

// NewClientService_useConfiguration_Results creates a new list of ClientService_useConfiguration_Results.
func NewClientService_useConfiguration_Results_List(s *capnp.Segment, sz int32) (ClientService_useConfiguration_Results_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return ClientService_useConfiguration_Results_List{l}, err
}

func (s ClientService_useConfiguration_Results_List) At(i int) ClientService_useConfiguration_Results {
	return ClientService_useConfiguration_Results{s.List.Struct(i)}
}

func (s ClientService_useConfiguration_Results_List) Set(i int, v ClientService_useConfiguration_Results) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s ClientService_useConfiguration_Results_List) String() string {
	str, _ := text.MarshalList(0x91f7a001ca145b9d, s.List)
	return str
}

// ClientService_useConfiguration_Results_Promise is a wrapper for a ClientService_useConfiguration_Results promised by a client call.
type ClientService_useConfiguration_Results_Promise struct{ *capnp.Pipeline }

func (p ClientService_useConfiguration_Results_Promise) Struct() (ClientService_useConfiguration_Results, error) {
	s, err := p.Pipeline.Struct()
	return ClientService_useConfiguration_Results{s}, err
}

func (p ClientService_useConfiguration_Results_Promise) Result() UseConfigurationResult_Promise {
	return UseConfigurationResult_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

const schema_db8274f9144abc7e = "x\xda\xacY}l]\xe5y\x7f\x9e\xf3^\xfb\xd8\x89" +
	"o\xae\x0f\xe7\"b\x13\xcbU\x04jCI\x06\xf1\xb2" +
	"\x11o\xeb\x8d\xed$\xb5\xdd|\xdc\xe3\x8f\x00!\x91r" +
	"r\xef\xeb\xeb\xe3\x9c{\xce\xcd\xf9\x08v\x946\x90\x85" +
	"\x01\x1e)\x09m&\x92\x86\x0a\xb2f|(]\x09\x0d" +
	"\xda\xca\xa0*\xd3\x18d\xad\x04h0\xc1\xc6\xfeX!" +
	"\x9a@\x8b\x18\xb4\x12\xa2*\x9c\xe99\xdf\xbe\xbeu\xc2" +
	"\xd4\x7f\x92\xab\xe7<\xef\xfb>\x9f\xbf\xe7\xc37e[" +
	"\xd7\x0977\x99Y\x00\xe5TS\xb3\xf7\xa7\xd5WO" +
	"\xff\xd1\xf1\x9f\x1f\x06\xa9S\xf0\xbe\xf5\xfcp\xfeS\xe7" +
	"\xd0\x7f\x00`\xcf#\xcd\xfbQ>\xd7,\x02\xc8?l" +
	"\xde\x0a\xe8\xfd\xebM\x07\xde\xdb\xf5\xabc\xf7\x81\xd4\x89" +
	"\x09gF\x04\xe8y\xa9y\x16\xe5\xffl\x16\x81y\x8f" +
	"\xdc\x91\xff\x17|\xf4\x93c }\x05\x01\x9a\x90>\xff" +
	"\xa4y\x91\x00(\xbf\xde\\\x00\xf4^\xbd\xf1\xf9\xe7\x8e" +
	"\xfe\xf8\xde\xef\x81\xf2eD\x08\xce\x7f\xd4\xfc\x1b\x04\x94" +
	"\x9bDb\xf8\xe8\x07_\xcd\xfc\xf0\xd5\xab\xbe\xef3x" +
	"g^\xbf\xf5\x99\xa3?\xfe\xd2\x070.\x88\x98\x01\xe8" +
	"Y)Z\xc4\xbbV\xfco@\xef\xbbo\xbd\xb0\xa5z" +
	"\xec\xe4i\x90\xbe\x1c\xdd\xd5\xd1\"\x08\x90\xf1\xd6\xfc\xfb" +
	"\xc5\xad\x9b\x9f\x99x<\xf8\x12\xc8\x91my\x86\x8ev" +
	"\xb5\xd03\xaf\xdc\xd9\xfe@\xdf\x1f?\xf88(\x9d\x98" +
	"\xd2\xa7\xa9\x898\xfbZfQ\xbe\xbd\x85~\x8e\xb7\xdc" +
	"\x8a\x80\xde\xec\xda\x17\xb6\xfd\xea/\xec\xa7@Y\x89\x19" +
	"\xef\x9f\xee\x7fw\xdf\x8a''^\xf6\xa5b\x00=\x17" +
	"ZO\xd3\xd5o\xb7\xfe\x08\xd0\xcb\xfe\xc3\x0d[\x1e|" +
	"o\xd39\xba:e\xd4@\x88\x99E\xbd(\xdf\xbf\x88" +
	"\xecz\xcf\"\xe2~\xed\xc6m?\xfd\xe9\xd3\x95s\xf5" +
	"\x82\x08\xc4}\xfd\xe2a\x94\xd7.&\xee5\x8b\x89\xfb" +
	"\xea!|\xe7g7g\xfe.\xd4\x8b\x11\xd3\xfb\x8b?" +
	"\xa0\xc7?\xf3\x19\xee\xf8\xed\xb3\xff\xb8\xe1\xc37~\x92" +
	"v\xc0#m\x029\xe0\\\x1b)\xdeu\xa9?k|" +
	"x\xe8gs\xfd\x18\xdc\xf4v\xdb0\xca\x97\xda\xe8\xb9" +
	"\xf7\xdb\xe8\xb6\xbfr\xdfz\xc3\x1c\x1e~\xa9^8\xff" +
	"\xda{\xb2\x02\xca\xc7\xb2\xc4}$[\x00\xfc\xe4\xa9{" +
	"\x8f\x0e\xbd\xbb\xfee\xa5\x133\xf5\xbc\xc7\xb2\xfbQ>" +
	"C\xbc=\x8fe\xbb\xc9\xa2\xb1\x0d\xeb\xd8}\xbd__" +
	"2\x85\xf2\xc5%\xf4\xf3\xbf\x96\xf8\xec\xc3w|\xe7\xa1" +
	"\xa6\x8b\xdfy\xb9\xde\xa8\xa2o\x81\x9c\x85\xf2g9\xfa" +
	"\xf9i\xeeq\x01\xd0\xfb\xcd\xd9?\xe7\x17W\xbdr\x01" +
	"\x94/aJ\x8dq\x14Q\x00\xe8\xb9x\xd5j2\xd9" +
	"\xa5\xab\xee\x04\xf4:\x9f\xfe\x93\xbf\xed/\xbf\xfd\xf3:" +
	"\x8b\x90 \xf2f\xf9c\xf9v\x99~\x8d\xcb\xc4{\xef" +
	"Wg\xf6o\xb9~\xf6\xcd\x86\x069'\xcf\xa2|\xc1" +
	"\xe7~\xc9\xe7\x16.\xaa\x1dw\xfd\xdb\xd7\xdeI\xc5\xe7" +
	"\x9a\xfc/\x112\xde\x96mwL\xb5~\xf3\xddw\xd3" +
	"\xf1\xb9\"\xef\xfb\xf1\xcf\xf2\xe4\xa6\xf3\xd2C\xf2\xf3\x8f" +
	"\xfd\xcd{\xf4\x90X\xef\xa7\x9d\xf9\xed(\xef\xcd\xd3\xcf" +
	"j\xde\xd77\xce\x93FQ\xa4]\xd3\x8b\xf2\xcc5$" +
	"\x97{\x0d\xc9\xb5fW\x1f\xdfq\xcbm\x1f\x80\xd4\xc9" +
	"\xe6d\xfd\xb3\xc4\xf9\x12q\xf6\xbcx\x8d\x88\xf2\xde\xa5" +
	"\"\x80\xf7\xed\xca\xf6\x0b\x1f\x0d<\xf6\xbf\xf5\x97\xfb\x0a" +
	"\xdd\xbe\xb4\x17e\x8d\xf8z\xf8R\xdfU=7\xff\xe5" +
	"\xa5\xe3\x7f=\xf0\xd1\xbc\xdb\xcfu\xf4\xa3\xfcb\x07\xc9" +
	"\xf1B\xc7\xd7\xe5K\x1d\xfe\xe5\xdfZ\xbfu\xed\xf2\x17" +
	"?N[\xe2\xcd\x8e\x8f\xc9\x12\xefw\x90%&n\xf9" +
	"\x9f\xaf_\xff\xed\x7f\xfe\xb8\xce=>ck\xe7\x0d(" +
	"wt\xd2\x8dWw\x16\x00?\xdc\xf8\xfd7:s\x9d" +
	"\xbfn$\xe8\xda\xce)\x947\x13o\xcfP\xa7/\xe8" +
	"m\xbf<yg\xe1{\xbf\xfe\x84\xf4bu\x986s" +
	"\xedv\x94\x8f\\K7\xdf\x7f-\xa5\xc2\xa6\xb3o\x7f" +
	"m\xf2\xf8+\x9f\xd6\x1b\xc1w\xc8\x9ae\x87P\x1eZ" +
	"F\xdc\x1b\x96\x112\x1d\xf8\xf0\xc4\xe0\x83;\xce~\x9e" +
	"\xd6je\xd7s\xbe\x7f\xbbH\xab\xa9\xe3\x07\x9c\xc1\x87" +
	"\x8fx\x8d\xd2pgW?\xca\xd5.\xbaM\xeb\xfa\x11" +
	"\xac\xf4\x1c\xd70\xb8n\xd52\xa5?\x88~\x96V\x95" +
	"\xd4\x9aQ\xeb\xdd0\xad\xd9\x8efT\xc6|z\xa1h" +
	"\xeaZi\xa6\x88\xa8\xb4Q\xa0K]\xbd\x00\x88\xd2\xd5" +
	"\xdb\x01P\x90\xa4~\x80\x82V1L\x8b{e\xcd." +
	"\x99\x86\xc1\x81\x95\x9c\x83\xbbU]5J<~\xa8i" +
	"\xfeC\x83\\\xd7\xcd[MK/o\xb5\xb4\x8af\x0c" +
	"\x98\xc6\x84V\x01(\"\xc6\xc7\xc4\xf9\xc7\x06t\x8d\x1b" +
	"\xce(\xb7\xf6i%\xbe\xca\xb5yp\xce\xb5TG3" +
	"\x8d\xebF\xb8\xed\xea\x8e\x0d\xa0dX\x06 \x83\x00R" +
	"\xb6\x17@ia\xa8\xe4\x05,X>\x03\xb6'\x99\x07" +
	"\x88\xed\x90\xbc\xd9<\xff\xcd\xc0\x16\xf4&\xb7V\xb9\x86" +
	"\xc5+\x9a\xedp+ _W(\xaa\x96Z\xb5\xd3\x0f" +
	"\x9e\x04P\xda\x19*\xcb\x04\xf4*\x96Z\xe2En\xa1" +
	"f\x96\xb7\xa8\x869\xcax\x09\x9b@\xc0\xa6\xd4\xa3\x0d" +
	"\x1c\xb1Q\xd5t^\x0e\xb4[U\xea\xf6\xffW\xdaY" +
	"\xa6\xcd\xf3\xfcG\xd4\xed\x00\xca.\x86\x8a.`\x16?" +
	"\xf7\xf2T\xfe$m?\x802\xc9Pq\x04\xcc\x0a\x9f" +
	"yy\xdfk{\x97\x03(:CeZ\xc0,\xfb\xad" +
	"\x97\xa7\"#\xb9S\x00\x8a\xc3P\xb9K@\xcfvk" +
	"dS\x1b\x98ia{\x12\xca\xa1ux\xb9B\x966" +
	"\xa0\xc0Kdhl\x8f\xd09`\x10\xcb\xe6$\xb6'" +
	"\xc5'<f\xf1}\xdc\xb2y\x11r\x969=\x83\xed" +
	"\x09J\xd7Y=\xfbE\xad\x1e9:>\xb5\xf0y?" +
	"4K\xceu\xc5\xeey\xce\";\xb61T\x96\x0a\xe8" +
	"\xd5\xe8+w80\xcb\xc6\xf6\xa4\xa8\xd7I\xdb \x9c" +
	"\x07\xe8\xdf\x81\xe0\x95bx\x8be\xfb\xe1\xac,\x8d\x1f" +
	";A\x8f=\xccP\xf9\x81\x80\x12b\xe0\xb3\xc7,\x00" +
	"\xe5Q\x86\xcaY\x01Q\x08<\xf6\xe4i\x00\xe5,C" +
	"\xe5\xef\x05\x94\x98\x108\xec\xd9\x1b\x00\x94\xa7\x19*\xbf" +
	"\x10P\xca\xb0<50\xd2\x05\x0a\xb6_0T\xde\x12" +
	"Pj\xca\xe4\xb1\x09@zs5\x80\xf2\x1aC\xe5\x1d" +
	"\x01=3\xc8/R\xca\xc1,\x08\x98\x05\xf4J\xba\xe9" +
	"\x96't\x15\xba-^\x1eZ\x1f\xd3\x0d\xb7Z\xb4\xf8" +
	">\x0dM\xd7\xees\x1c^\x15k\x8e\x8d\xcd `3" +
	"`\xceQ+6.\x01,2\xc4\xf6\xa4\xd0\x01\x121" +
	"\xbe\x13-^\xde\xc6-[c\xa6\x81m `\x1b`" +
	"\xb7]2k\x1c\xdb\x93\xdayy\x9b\x8e\x84\xd1C\xb1" +
	"\x13&\x82iibE3\x946\x96Y\xe6y\xa1\x01" +
	"7\x90]\xd61T6\x09\xd8\x85\x9f\x13\x99l84" +
	"\x02\xa0\x0c2T\xc6\x04\xec\x12>#2YQ!\x1f" +
	"\x14\x19*;\x04\xccM:N\x0d\xdb\x93\xea\x18\x0au" +
	"'\xdfm\x9b\xa5=\x1c\x90\xa0\"\x86\xea\xf0\xebd\x08" +
	"]\xc0\xf42\xb6'\x9dl\x9dF\xacA\x94\xf8\x01R" +
	"p6X\x96i\xf9\xa8\x1a\x87\xc6\x86\xd5\x89\x12Qd" +
	"\x0cmO4\x90\x84u\x81Z\xca\xeeD\xfe\xee\x92\xea" +
	"\xda<\xb2\xb1gq\xc7\x9a\xe9\x9bp\x80q+\xc6\x18" +
	"{\xd2t\xf5\xf2\x08\x07\xd1\xb1f\x10A@\\\x18y" +
	"\xd6\x9b\x83)\x93\x07!\x9c\x92\x93dZ\xcfP)&" +
	"rn&\xda&\x86\xcam$gh\xfeq2\xff\x18" +
	"C\xa5&\xa0\xa7S\xee\x1a\x83&0\xdb\x89\xc5\x0d\x88" +
	"E\xd3\x0fL\x11\x04\x14\x01=\xb7f;\x16W\xab\x80" +
	"q\xa4\x11\xff\x92/\x00\xd1uPQTs~\xce7" +
	"\xd6!N\xc3\xcd\xc3i%\xc2<\x1c\xefO\x8c\xdd8" +
	"\x91&M\xdb1\xd4*\x07\x80H\xb1\x83f\x8d0\x92" +
	"\x10$n3\xebb\xe3\x8bW\xb6\xa0\xca\xcc\xa9k\xa7" +
	"Se\xa6\x14\x9eF\xff\xf8\x80i\x88\x13Z\x05\xdb\x93" +
	"^\xabN\x80\x06~\xefs\x9dIn8Z\xc9\x7fp" +
	"\x9e\xdf\x97'\xf1\x19\xdblhu\xca\x90\x91\xcd6\xef" +
	"N\x0c)\xee\xe131\x04\xf0\xaa\xaa\xe9\xb1\xf7Ck" +
	"\xf6\x81\xf8\x8d\x84g\xa1\xe4\x19%\x04\xf1\xa5\xf2m\x80" +
	"\xa9\xae\\\xca\xae\x06\xa1{\x9f\xaa\xbb|\xc1\xe6&\xac" +
	"bA\x0d+\x04\x06\xa6\x0b\xf3\xb1\x9a\xdf\x9c\x05P\xee" +
	"b\xa8<\x90R\xf3\xfe\x87\x00\x94\x07\x18*\x0f\xa7\xd4" +
	"<N\xa1q\x94\xa1r\x8a \x9a\x05\xe0r\x82|r" +
	"\x8a\xa1\xf2\x84\x80\x98\x09\x10\xfa\x0c!\xf4\x13\x0c\x95\xf3" +
	"\x82\x8f\xaf\x83}\x03\xa6\x81\xa1\x106@\x84\xae\xde$" +
	"W-g7W\xd1\x192\x1cn\xedSQ\x8f\xb2\xf8" +
	"\xa0\xa3U\xb9\xe9:qVW\xd5i\xbfC\xc0\xf2`" +
	"pJT\x1d\x1b[A\xc0VJ\"\x9b[\x03\x16/" +
	"#\xf9S\xd5\x8b*s&\xe7\x998s9\xc4\xcd5" +
	"0\x0f\xf5\x17\x07\x18*\xf7Q\xf6cj\x90\x95\xee\xe9" +
	"\x05\xc1O~\xd2\xb9\xda\x9f\xf4!~\xfd\xa2\xaa\xb4\xf7" +
	"\xa1\xa4\xe1\xf0\xebW3\xddx21x(\xda\xa0\x09" +
	"\x85 \xa9\"\x99\x0bA\xb0\x1c$\x80\xd3x\xa2gX" +
	"\xd654\x8d1\xdf@\x98X\xa8dVk\x16\xb7m" +
	"\xd4LCqU]c\xceL|pA\x1b\x10z\x04" +
	"Y\xb7\xb5\xd6\xed;\x89\x8cpSd\x04\xb9\x0f\x87\x01" +
	"F\xd7!\xc3\xd1M\x98\x84\x89<\x84\xfd\x00\xa3\xeb\x89" +
	"^\xc4$R\xe4\xcd\xd8\x090:H\xf41\x14\x10\x83" +
	"X\x91\x15|\x0a`t\x8c\xc8\xbb0\xa9\xe8\xf2N\xff" +
	"\xfa\x1dD\x9f\xc4\xa4\xa8\xcb\x1co\x00\x18\xddE\xf4\x03" +
	"Do\x16|\x0b\xca38\x050:M\xf4\xc3D\x17" +
	"\x9b\xf24\x1f\xc8w\xa3\x050z\x17\xd1\x1f z\xcb" +
	"\xd2<\xb6\xd0\xfc\xe1\xd3\xef#\xfaw\x89\xde\xda\x91\xc7" +
	"V\x00\xf9\x18\x1e\x02\x18=J\xf4SD_\x84y\\" +
	"\x04 \x9f\xc0\x93\x00\xa3\xa7\x88\xfe\x04\xd1\x177\xe7q" +
	"1\x80|\xc6\x97\xe7Q\xa2\x9f\xc5\x18\x82\x86\xcai$" +
	"\xa4p\xd2\x92.\x80\x99v\x1c\x86<\x9c40\x80\xe9" +
	"\xa2\x99\xa3Q\x03s\xc9\x0e\x09\x10s\x80^\xcd4\xf5" +
	"-s\x11\xf6r\x8dH\x18\x16\x903\x8d\xa1r\x9c_" +
	"A\x10m2\xa1\xbb\xa4\xeaC\xb5X\x12\xcd\xees\x1d" +
	"\xd3\xadAwYux9\xae\x91\x96kl\xb4\xcc\xea" +
	"\x18r\xab\xaa\x19\xaa\x0e\xf1\x97\x85b+\xe7\xbaZ\xf9" +
	"\x8a\xf1lU\x80ZJK\xd2\xd9\xaf\xa0\xea\xf4\x15\x86" +
	"\xca\x1f\xa6;\xfb\x9b\x09jod\xa8\xdcB\xdd\xfa\x8c" +
	"\xed\xf0\xea\x16\x15X\x92#\xdd\x15\xcbtk\xf3\x1e\x16" +
	"\xea\x1f\xee\xae\xf5\x8e\xa9~Z\xb7\xc4i\xbd\x82:\xa8" +
	"\xeb\x18*7\xa5Po\xe5\xeaD\x8e\\:\x1b\x03\x91" +
	"\xe7\xbd\xd4\xa0\x83\x1b\xaf\xabbA\xd7\x1e\x94\x96\xd4\xeb" +
	"\xfd\xc9\xeb\xf1\xe3V\xa8\xee\xa0\x80\x07m\xb7T\"k" +
	"G\xe6\x9f\x08g#\xe8\xa6\xbbS\x81\x10\xaf-\xc2@" +
	"\xb8\xd2\x8e\xa1\xc2\x9d\xe0\xd7\x901aR\xa9\x15\xd5\xaa" +
	"\xfd\xff<=\xc2\xed\x1c\x8d&\x97\x9d@\xe3E\xc4\xe5" +
	"K\xf3\xe0\xd8X1\x19\x93Y\x80\xcai@\x1aI\x03" +
	"R\x82GSi\xdc\x89:HY\xf1\x01\xa0H\xf4\x1d" +
	"\x98\xcc\x17\xf2\xedxz\x0e\xf0d\xfa\x02@\xe2\xfe\xf5" +
	"e\xa2\xd7|@\xc2\x00\x90\xaa\xfe\xfd:\xd1\xa7\xd3\x80" +
	"\xe4\xe2\xec\\@b\x11 \x11\x90\x1c&\xfaQ\x1f\x90" +
	"2\x01 \x1d\xc1g\xe6\x00OkS\x00H'\xf0\xb9" +
	"9\xc0\xb3\xa89\x00\xa43>\xff\x13D?\xef\x03R" +
	"\x7f\x00H\xe7|\x00{\x9a\xe8\xcf\x13 \xb9\x96>\xea" +
	"X\x9a\x01XI\x82\xb5T\xfb\x06\xe7\xb5>\xc8\xe9\xda" +
	">\x1e\x17\x8b\xb2\xa6\xea\xeb]U\x87\xeeQG-\xed" +
	"I\xdad\xdd\x1eT\x8d\xb2\x8d\x93\xea\x1eN%FL" +
	"\x17aG\xb7\xb7qK\x9b\x00L\x1a\xeb\xb8\xad\xc9\x15" +
	"M\xb3\xbe\xdb\xf1\xfb3n\x05h\x16\x7f\xab\xaa\xd3C" +
	"e\x9d\x0f`\xd4\x9a0#)q\x1a}1\x0d\x03\x83" +
	"~aL\xeb\x9e\xdb\x08\xd4\xc2V=j(\xc6\x0au" +
	"\x9d\x02\x9f\xae\xf1\x923`\xa2\xe1h\x86\xcb\xe7]P" +
	"\x9at\x8d=\xbc\xbc\x01\x8d\x92Y\xd6\x8c\x0a\xcc\x9b\x11" +
	"\xd8\xef\xdaN\xa4:\xa8\x96\xb0%\x8b\xd7\xed\xd2\x0a\xea" +
	"\x070\xec\x07\xa4\xded\xca.\x94\xfcS\x05\x8b\xabv" +
	"R\x1a\x16z-\\F\x05IF\xaf\xb5\xb3&\x80x" +
	"y\x8d\xd1\xceO\xda\xbb\x1f\x04I\x131Y\x95b\xb4" +
	"\x19\x95vZ H\xe3\"\x0a\xf1\xdf\x0c0\xda\xf7K" +
	"C\xb3 H\x1bDd\xf1\xa2\x1f\xa3\x8d\x9b\xb4\xb6\x1f" +
	"\x04i\xa5\xe8ES\x05\x14\x02q\xd6\xa1\x17%>t" +
	"\xfb\xa9\xbf\x0e\xbdhO\x81\xd1\xf4\x01\xb0\x0e\x0f\x86\xf5" +
	"h\x1d\xa6\x97[\xecw\x8d\x00\x8d\xfbR\xc2\xc8i\x86" +
	"\xca\xe1\x04#\xef\xa6^\xf50C\xe5hj\xec:\xf2" +
	"T\xba-\x0d7\x07'\x0e\x85{\x87\xf3\xa9\xcd\xc19" +
	"\xeaU\xcf3T^\x13\x92B\x1d\x85]\xb4\x0fB\xd3" +
	"\x8a\xe6\xc0\x05\xd6Bap\x86-c\xfdr\xc8+\x9b" +
	"\x93~K\x89\xc1U6$\x88\x9d\xde\x18-Im\x8c" +
	"0\x9a@\xc59\x00\x9f\xde\x1f-Y\x183\xe7\xccS" +
	"\xe1\xd8@Q\x13\xfdE\x03\xa3\xbf-I\x12y?+" +
	"z\xd1\xcc\x85Q\xb9\"\xe7\xa5]\xf6\x05\x07\xcf\x11\xde" +
	"m_I%\x88\xb6\xcc\x97\xdf\x1f\x04\xef\xe4(\xd8\xe2" +
	"9(\xb8w*\xb5\xc5\xd2\xcdp\x84\xcbmIU\xed" +
	"\x85l\x15\x08\x1cu\xbe9:\\\x17~\xcb\x93\xf0\x8b" +
	"\x1b\x84\xbb\x97'\xc3@<\x16\xdd3\x1c\x06\xe5\xa3q" +
	"\xa7+=2\x9bl\xb8\xe2\xf0{r8\x19\x8bDn" +
	"Y\x91\x9c\xa2k%\xb0\xa9\x9b\x95M\x9a\xc1m\xea\xfd" +
	"\xea\xb6\x015nUU\x83\x1b\xe8\x10\x18\xb9\x16!\xea" +
	"\\\xe4\x1aZ\x9fj\x19\x17R\x7f4\x0c\xf6 \xd6\xc3" +
	"\xf2\x9a\x1a}O\xa7\xd60\x91\xf2\xcas\xe1zcW" +
	"J\xf9\x9d4\xfa\xee`\xa8L\x0a\xe8\xa9\xaec\x8e\xd7" +
	"\xca*:|\xa3\xc5\xf7\xba\\4J3\xc9\x00G\xa3" +
	"L\xc9\x1e\xc7\x1a5\x9d\x1b-^\xd8\xeb\xf24C\xb4" +
	"8\x06Q3\xcb\xf36\xc6\x0d\x9a\xad[\xf9\xeeQ\xb3" +
	"\xb4\x87;s\x16\xea\x01\\F\xaa\xa8#\xc9\xd68\xd2" +
	"D\x1bI\xcdj\x11\x8c\xec\xa5\x80\xaa1T\x0e\xa4`" +
	"df6qx\xe3\xea\xfa\xfb)\x88\x0b(\xd9p\xab" +
	";R\xe0W\x94h\xc9_I.\xdfr\x85{\x82\xb0" +
	"c\xbd\x92]\xc8\x9ce]\x18\x10\xcaT\xb2?\xf2\x83" +
	"\xbc=\xf9sn(\x83\x1d\xb6\x8e\xc0&\xcc\x06]a" +
	"0U\x0d\x98\x10Bk\xfdF\xe7\xff\x02\x00\x00\xff\xff" +
	"\xd4\xcdz3"

func init() {
	schemas.Register(schema_db8274f9144abc7e,
		0x84cb9536a2cf6d3c,
		0x8891f360e47c30d3,
		0x91f7a001ca145b9d,
		0x9b87b390babc2ccf,
		0x9e12cfad042ba4f1,
		0xa29a916d4ebdd894,
		0xa766b24d4fe5da35,
		0xa78f37418c1077c8,
		0xaa7386f356bd398a,
		0xb14ce48f4e2abb0d,
		0xb167b0bebe562cd0,
		0xb70431c0dc014915,
		0xb9d4ef45c2b5fc5b,
		0xc082ef6e0d42ed1d,
		0xc54a4a6fd4d87596,
		0xc744e349009087aa,
		0xc766a92976e389c4,
		0xc793e50592935b4a,
		0xc9c82ee56583acfa,
		0xcbd96442ae3bb01a,
		0xd58a254e7a792b87,
		0xdc3ed6801961e502,
		0xe3e37d096a5b564e,
		0xe4a6a1bc139211b4,
		0xea20b390b257d1a5,
		0xea58385c65416035,
		0xf0a143f1c95a678e,
		0xf143a395ed8b3133,
		0xf2c122394f447e8e,
		0xf2c68e2547ec3866,
		0xf41a0f001ad49e46,
		0xf7f49b3f779ae258,
		0xf9c895683ed9ac4c,
		0xfeac5c8f4899ef7c,
		0xff8d9848747c956a)
}