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

package testcapnp

import (
	capnp "capnproto.org/go/capnp/v3"
	text "capnproto.org/go/capnp/v3/encoding/text"
	fc "capnproto.org/go/capnp/v3/flowcontrol"
	schemas "capnproto.org/go/capnp/v3/schemas"
	server "capnproto.org/go/capnp/v3/server"
	stream "capnproto.org/go/capnp/v3/std/capnp/stream"
	context "context"
)

type Empty capnp.Client

// Empty_TypeID is the unique identifier for the type Empty.
const Empty_TypeID = 0xc8b14e937b2cb741

func (c Empty) WaitStreaming() error {
	return capnp.Client(c).WaitStreaming()
}

// String returns a string that identifies this capability for debugging
// purposes.  Its format should not be depended on: in particular, it
// should not be used to compare clients.  Use IsSame to compare clients
// for equality.
func (c Empty) String() string {
	return "Empty(" + capnp.Client(c).String() + ")"
}

// AddRef creates a new Client that refers to the same capability as c.
// If c is nil or has resolved to null, then AddRef returns nil.
func (c Empty) AddRef() Empty {
	return Empty(capnp.Client(c).AddRef())
}

// Release releases a capability reference.  If this is the last
// reference to the capability, then the underlying resources associated
// with the capability will be released.
//
// Release will panic if c has already been released, but not if c is
// nil or resolved to null.
func (c Empty) Release() {
	capnp.Client(c).Release()
}

// Resolve blocks until the capability is fully resolved or the Context
// expires.
func (c Empty) Resolve(ctx context.Context) error {
	return capnp.Client(c).Resolve(ctx)
}

func (c Empty) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Client(c).EncodeAsPtr(seg)
}

func (Empty) DecodeFromPtr(p capnp.Ptr) Empty {
	return Empty(capnp.Client{}.DecodeFromPtr(p))
}

// IsValid reports whether c is a valid reference to a capability.
// A reference is invalid if it is nil, has resolved to null, or has
// been released.
func (c Empty) IsValid() bool {
	return capnp.Client(c).IsValid()
}

// IsSame reports whether c and other refer to a capability created by the
// same call to NewClient.  This can return false negatives if c or other
// are not fully resolved: use Resolve if this is an issue.  If either
// c or other are released, then IsSame panics.
func (c Empty) IsSame(other Empty) bool {
	return capnp.Client(c).IsSame(capnp.Client(other))
}

// Update the flowcontrol.FlowLimiter used to manage flow control for
// this client. This affects all future calls, but not calls already
// waiting to send. Passing nil sets the value to flowcontrol.NopLimiter,
// which is also the default.
func (c Empty) SetFlowLimiter(lim fc.FlowLimiter) {
	capnp.Client(c).SetFlowLimiter(lim)
}

// Get the current flowcontrol.FlowLimiter used to manage flow control
// for this client.
func (c Empty) GetFlowLimiter() fc.FlowLimiter {
	return capnp.Client(c).GetFlowLimiter()
}

// A Empty_Server is a Empty with a local implementation.
type Empty_Server interface {
}

// Empty_NewServer creates a new Server from an implementation of Empty_Server.
func Empty_NewServer(s Empty_Server) *server.Server {
	c, _ := s.(server.Shutdowner)
	return server.New(Empty_Methods(nil, s), s, c)
}

// Empty_ServerToClient creates a new Client from an implementation of Empty_Server.
// The caller is responsible for calling Release on the returned Client.
func Empty_ServerToClient(s Empty_Server) Empty {
	return Empty(capnp.NewClient(Empty_NewServer(s)))
}

// Empty_Methods appends Methods to a slice that invoke the methods on s.
// This can be used to create a more complicated Server.
func Empty_Methods(methods []server.Method, s Empty_Server) []server.Method {
	if cap(methods) == 0 {
		methods = make([]server.Method, 0, 0)
	}

	return methods
}

// Empty_List is a list of Empty.
type Empty_List = capnp.CapList[Empty]

// NewEmpty creates a new list of Empty.
func NewEmpty_List(s *capnp.Segment, sz int32) (Empty_List, error) {
	l, err := capnp.NewPointerList(s, sz)
	return capnp.CapList[Empty](l), err
}

type EmptyProvider capnp.Client

// EmptyProvider_TypeID is the unique identifier for the type EmptyProvider.
const EmptyProvider_TypeID = 0xea38d4d6dca1e80e

func (c EmptyProvider) GetEmpty(ctx context.Context, params func(EmptyProvider_getEmpty_Params) error) (EmptyProvider_getEmpty_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xea38d4d6dca1e80e,
			MethodID:      0,
			InterfaceName: "test.capnp:EmptyProvider",
			MethodName:    "getEmpty",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
		s.PlaceArgs = func(s capnp.Struct) error { return params(EmptyProvider_getEmpty_Params(s)) }
	}

	ans, release := capnp.Client(c).SendCall(ctx, s)
	return EmptyProvider_getEmpty_Results_Future{Future: ans.Future()}, release

}

func (c EmptyProvider) WaitStreaming() error {
	return capnp.Client(c).WaitStreaming()
}

// String returns a string that identifies this capability for debugging
// purposes.  Its format should not be depended on: in particular, it
// should not be used to compare clients.  Use IsSame to compare clients
// for equality.
func (c EmptyProvider) String() string {
	return "EmptyProvider(" + capnp.Client(c).String() + ")"
}

// AddRef creates a new Client that refers to the same capability as c.
// If c is nil or has resolved to null, then AddRef returns nil.
func (c EmptyProvider) AddRef() EmptyProvider {
	return EmptyProvider(capnp.Client(c).AddRef())
}

// Release releases a capability reference.  If this is the last
// reference to the capability, then the underlying resources associated
// with the capability will be released.
//
// Release will panic if c has already been released, but not if c is
// nil or resolved to null.
func (c EmptyProvider) Release() {
	capnp.Client(c).Release()
}

// Resolve blocks until the capability is fully resolved or the Context
// expires.
func (c EmptyProvider) Resolve(ctx context.Context) error {
	return capnp.Client(c).Resolve(ctx)
}

func (c EmptyProvider) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Client(c).EncodeAsPtr(seg)
}

func (EmptyProvider) DecodeFromPtr(p capnp.Ptr) EmptyProvider {
	return EmptyProvider(capnp.Client{}.DecodeFromPtr(p))
}

// IsValid reports whether c is a valid reference to a capability.
// A reference is invalid if it is nil, has resolved to null, or has
// been released.
func (c EmptyProvider) IsValid() bool {
	return capnp.Client(c).IsValid()
}

// IsSame reports whether c and other refer to a capability created by the
// same call to NewClient.  This can return false negatives if c or other
// are not fully resolved: use Resolve if this is an issue.  If either
// c or other are released, then IsSame panics.
func (c EmptyProvider) IsSame(other EmptyProvider) bool {
	return capnp.Client(c).IsSame(capnp.Client(other))
}

// Update the flowcontrol.FlowLimiter used to manage flow control for
// this client. This affects all future calls, but not calls already
// waiting to send. Passing nil sets the value to flowcontrol.NopLimiter,
// which is also the default.
func (c EmptyProvider) SetFlowLimiter(lim fc.FlowLimiter) {
	capnp.Client(c).SetFlowLimiter(lim)
}

// Get the current flowcontrol.FlowLimiter used to manage flow control
// for this client.
func (c EmptyProvider) GetFlowLimiter() fc.FlowLimiter {
	return capnp.Client(c).GetFlowLimiter()
}

// A EmptyProvider_Server is a EmptyProvider with a local implementation.
type EmptyProvider_Server interface {
	GetEmpty(context.Context, EmptyProvider_getEmpty) error
}

// EmptyProvider_NewServer creates a new Server from an implementation of EmptyProvider_Server.
func EmptyProvider_NewServer(s EmptyProvider_Server) *server.Server {
	c, _ := s.(server.Shutdowner)
	return server.New(EmptyProvider_Methods(nil, s), s, c)
}

// EmptyProvider_ServerToClient creates a new Client from an implementation of EmptyProvider_Server.
// The caller is responsible for calling Release on the returned Client.
func EmptyProvider_ServerToClient(s EmptyProvider_Server) EmptyProvider {
	return EmptyProvider(capnp.NewClient(EmptyProvider_NewServer(s)))
}

// EmptyProvider_Methods appends Methods to a slice that invoke the methods on s.
// This can be used to create a more complicated Server.
func EmptyProvider_Methods(methods []server.Method, s EmptyProvider_Server) []server.Method {
	if cap(methods) == 0 {
		methods = make([]server.Method, 0, 1)
	}

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xea38d4d6dca1e80e,
			MethodID:      0,
			InterfaceName: "test.capnp:EmptyProvider",
			MethodName:    "getEmpty",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.GetEmpty(ctx, EmptyProvider_getEmpty{call})
		},
	})

	return methods
}

// EmptyProvider_getEmpty holds the state for a server call to EmptyProvider.getEmpty.
// See server.Call for documentation.
type EmptyProvider_getEmpty struct {
	*server.Call
}

// Args returns the call's arguments.
func (c EmptyProvider_getEmpty) Args() EmptyProvider_getEmpty_Params {
	return EmptyProvider_getEmpty_Params(c.Call.Args())
}

// AllocResults allocates the results struct.
func (c EmptyProvider_getEmpty) AllocResults() (EmptyProvider_getEmpty_Results, error) {
	r, err := c.Call.AllocResults(capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return EmptyProvider_getEmpty_Results(r), err
}

// EmptyProvider_List is a list of EmptyProvider.
type EmptyProvider_List = capnp.CapList[EmptyProvider]

// NewEmptyProvider creates a new list of EmptyProvider.
func NewEmptyProvider_List(s *capnp.Segment, sz int32) (EmptyProvider_List, error) {
	l, err := capnp.NewPointerList(s, sz)
	return capnp.CapList[EmptyProvider](l), err
}

type EmptyProvider_getEmpty_Params capnp.Struct

// EmptyProvider_getEmpty_Params_TypeID is the unique identifier for the type EmptyProvider_getEmpty_Params.
const EmptyProvider_getEmpty_Params_TypeID = 0x9a27082d77b8c289

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

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

func ReadRootEmptyProvider_getEmpty_Params(msg *capnp.Message) (EmptyProvider_getEmpty_Params, error) {
	root, err := msg.Root()
	return EmptyProvider_getEmpty_Params(root.Struct()), err
}

func (s EmptyProvider_getEmpty_Params) String() string {
	str, _ := text.Marshal(0x9a27082d77b8c289, capnp.Struct(s))
	return str
}

func (s EmptyProvider_getEmpty_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (EmptyProvider_getEmpty_Params) DecodeFromPtr(p capnp.Ptr) EmptyProvider_getEmpty_Params {
	return EmptyProvider_getEmpty_Params(capnp.Struct{}.DecodeFromPtr(p))
}

func (s EmptyProvider_getEmpty_Params) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s EmptyProvider_getEmpty_Params) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s EmptyProvider_getEmpty_Params) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s EmptyProvider_getEmpty_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}

// EmptyProvider_getEmpty_Params_List is a list of EmptyProvider_getEmpty_Params.
type EmptyProvider_getEmpty_Params_List = capnp.StructList[EmptyProvider_getEmpty_Params]

// NewEmptyProvider_getEmpty_Params creates a new list of EmptyProvider_getEmpty_Params.
func NewEmptyProvider_getEmpty_Params_List(s *capnp.Segment, sz int32) (EmptyProvider_getEmpty_Params_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
	return capnp.StructList[EmptyProvider_getEmpty_Params](l), err
}

// EmptyProvider_getEmpty_Params_Future is a wrapper for a EmptyProvider_getEmpty_Params promised by a client call.
type EmptyProvider_getEmpty_Params_Future struct{ *capnp.Future }

func (f EmptyProvider_getEmpty_Params_Future) Struct() (EmptyProvider_getEmpty_Params, error) {
	p, err := f.Future.Ptr()
	return EmptyProvider_getEmpty_Params(p.Struct()), err
}

type EmptyProvider_getEmpty_Results capnp.Struct

// EmptyProvider_getEmpty_Results_TypeID is the unique identifier for the type EmptyProvider_getEmpty_Results.
const EmptyProvider_getEmpty_Results_TypeID = 0x93281cc60d6060cd

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

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

func ReadRootEmptyProvider_getEmpty_Results(msg *capnp.Message) (EmptyProvider_getEmpty_Results, error) {
	root, err := msg.Root()
	return EmptyProvider_getEmpty_Results(root.Struct()), err
}

func (s EmptyProvider_getEmpty_Results) String() string {
	str, _ := text.Marshal(0x93281cc60d6060cd, capnp.Struct(s))
	return str
}

func (s EmptyProvider_getEmpty_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (EmptyProvider_getEmpty_Results) DecodeFromPtr(p capnp.Ptr) EmptyProvider_getEmpty_Results {
	return EmptyProvider_getEmpty_Results(capnp.Struct{}.DecodeFromPtr(p))
}

func (s EmptyProvider_getEmpty_Results) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s EmptyProvider_getEmpty_Results) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s EmptyProvider_getEmpty_Results) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s EmptyProvider_getEmpty_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s EmptyProvider_getEmpty_Results) Empty() Empty {
	p, _ := capnp.Struct(s).Ptr(0)
	return Empty(p.Interface().Client())
}

func (s EmptyProvider_getEmpty_Results) HasEmpty() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s EmptyProvider_getEmpty_Results) SetEmpty(v Empty) error {
	if !v.IsValid() {
		return capnp.Struct(s).SetPtr(0, capnp.Ptr{})
	}
	seg := s.Segment()
	in := capnp.NewInterface(seg, seg.Message().CapTable().Add(capnp.Client(v)))
	return capnp.Struct(s).SetPtr(0, in.ToPtr())
}

// EmptyProvider_getEmpty_Results_List is a list of EmptyProvider_getEmpty_Results.
type EmptyProvider_getEmpty_Results_List = capnp.StructList[EmptyProvider_getEmpty_Results]

// NewEmptyProvider_getEmpty_Results creates a new list of EmptyProvider_getEmpty_Results.
func NewEmptyProvider_getEmpty_Results_List(s *capnp.Segment, sz int32) (EmptyProvider_getEmpty_Results_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return capnp.StructList[EmptyProvider_getEmpty_Results](l), err
}

// EmptyProvider_getEmpty_Results_Future is a wrapper for a EmptyProvider_getEmpty_Results promised by a client call.
type EmptyProvider_getEmpty_Results_Future struct{ *capnp.Future }

func (f EmptyProvider_getEmpty_Results_Future) Struct() (EmptyProvider_getEmpty_Results, error) {
	p, err := f.Future.Ptr()
	return EmptyProvider_getEmpty_Results(p.Struct()), err
}
func (p EmptyProvider_getEmpty_Results_Future) Empty() Empty {
	return Empty(p.Future.Field(0, nil).Client())
}

type PingPong capnp.Client

// PingPong_TypeID is the unique identifier for the type PingPong.
const PingPong_TypeID = 0xf004c474c2f8ee7a

func (c PingPong) EchoNum(ctx context.Context, params func(PingPong_echoNum_Params) error) (PingPong_echoNum_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xf004c474c2f8ee7a,
			MethodID:      0,
			InterfaceName: "test.capnp:PingPong",
			MethodName:    "echoNum",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 0}
		s.PlaceArgs = func(s capnp.Struct) error { return params(PingPong_echoNum_Params(s)) }
	}

	ans, release := capnp.Client(c).SendCall(ctx, s)
	return PingPong_echoNum_Results_Future{Future: ans.Future()}, release

}

func (c PingPong) WaitStreaming() error {
	return capnp.Client(c).WaitStreaming()
}

// String returns a string that identifies this capability for debugging
// purposes.  Its format should not be depended on: in particular, it
// should not be used to compare clients.  Use IsSame to compare clients
// for equality.
func (c PingPong) String() string {
	return "PingPong(" + capnp.Client(c).String() + ")"
}

// AddRef creates a new Client that refers to the same capability as c.
// If c is nil or has resolved to null, then AddRef returns nil.
func (c PingPong) AddRef() PingPong {
	return PingPong(capnp.Client(c).AddRef())
}

// Release releases a capability reference.  If this is the last
// reference to the capability, then the underlying resources associated
// with the capability will be released.
//
// Release will panic if c has already been released, but not if c is
// nil or resolved to null.
func (c PingPong) Release() {
	capnp.Client(c).Release()
}

// Resolve blocks until the capability is fully resolved or the Context
// expires.
func (c PingPong) Resolve(ctx context.Context) error {
	return capnp.Client(c).Resolve(ctx)
}

func (c PingPong) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Client(c).EncodeAsPtr(seg)
}

func (PingPong) DecodeFromPtr(p capnp.Ptr) PingPong {
	return PingPong(capnp.Client{}.DecodeFromPtr(p))
}

// IsValid reports whether c is a valid reference to a capability.
// A reference is invalid if it is nil, has resolved to null, or has
// been released.
func (c PingPong) IsValid() bool {
	return capnp.Client(c).IsValid()
}

// IsSame reports whether c and other refer to a capability created by the
// same call to NewClient.  This can return false negatives if c or other
// are not fully resolved: use Resolve if this is an issue.  If either
// c or other are released, then IsSame panics.
func (c PingPong) IsSame(other PingPong) bool {
	return capnp.Client(c).IsSame(capnp.Client(other))
}

// Update the flowcontrol.FlowLimiter used to manage flow control for
// this client. This affects all future calls, but not calls already
// waiting to send. Passing nil sets the value to flowcontrol.NopLimiter,
// which is also the default.
func (c PingPong) SetFlowLimiter(lim fc.FlowLimiter) {
	capnp.Client(c).SetFlowLimiter(lim)
}

// Get the current flowcontrol.FlowLimiter used to manage flow control
// for this client.
func (c PingPong) GetFlowLimiter() fc.FlowLimiter {
	return capnp.Client(c).GetFlowLimiter()
}

// A PingPong_Server is a PingPong with a local implementation.
type PingPong_Server interface {
	EchoNum(context.Context, PingPong_echoNum) error
}

// PingPong_NewServer creates a new Server from an implementation of PingPong_Server.
func PingPong_NewServer(s PingPong_Server) *server.Server {
	c, _ := s.(server.Shutdowner)
	return server.New(PingPong_Methods(nil, s), s, c)
}

// PingPong_ServerToClient creates a new Client from an implementation of PingPong_Server.
// The caller is responsible for calling Release on the returned Client.
func PingPong_ServerToClient(s PingPong_Server) PingPong {
	return PingPong(capnp.NewClient(PingPong_NewServer(s)))
}

// PingPong_Methods appends Methods to a slice that invoke the methods on s.
// This can be used to create a more complicated Server.
func PingPong_Methods(methods []server.Method, s PingPong_Server) []server.Method {
	if cap(methods) == 0 {
		methods = make([]server.Method, 0, 1)
	}

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xf004c474c2f8ee7a,
			MethodID:      0,
			InterfaceName: "test.capnp:PingPong",
			MethodName:    "echoNum",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.EchoNum(ctx, PingPong_echoNum{call})
		},
	})

	return methods
}

// PingPong_echoNum holds the state for a server call to PingPong.echoNum.
// See server.Call for documentation.
type PingPong_echoNum struct {
	*server.Call
}

// Args returns the call's arguments.
func (c PingPong_echoNum) Args() PingPong_echoNum_Params {
	return PingPong_echoNum_Params(c.Call.Args())
}

// AllocResults allocates the results struct.
func (c PingPong_echoNum) AllocResults() (PingPong_echoNum_Results, error) {
	r, err := c.Call.AllocResults(capnp.ObjectSize{DataSize: 8, PointerCount: 0})
	return PingPong_echoNum_Results(r), err
}

// PingPong_List is a list of PingPong.
type PingPong_List = capnp.CapList[PingPong]

// NewPingPong creates a new list of PingPong.
func NewPingPong_List(s *capnp.Segment, sz int32) (PingPong_List, error) {
	l, err := capnp.NewPointerList(s, sz)
	return capnp.CapList[PingPong](l), err
}

type PingPong_echoNum_Params capnp.Struct

// PingPong_echoNum_Params_TypeID is the unique identifier for the type PingPong_echoNum_Params.
const PingPong_echoNum_Params_TypeID = 0xd797e0a99edf0921

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

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

func ReadRootPingPong_echoNum_Params(msg *capnp.Message) (PingPong_echoNum_Params, error) {
	root, err := msg.Root()
	return PingPong_echoNum_Params(root.Struct()), err
}

func (s PingPong_echoNum_Params) String() string {
	str, _ := text.Marshal(0xd797e0a99edf0921, capnp.Struct(s))
	return str
}

func (s PingPong_echoNum_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (PingPong_echoNum_Params) DecodeFromPtr(p capnp.Ptr) PingPong_echoNum_Params {
	return PingPong_echoNum_Params(capnp.Struct{}.DecodeFromPtr(p))
}

func (s PingPong_echoNum_Params) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s PingPong_echoNum_Params) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s PingPong_echoNum_Params) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s PingPong_echoNum_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s PingPong_echoNum_Params) N() int64 {
	return int64(capnp.Struct(s).Uint64(0))
}

func (s PingPong_echoNum_Params) SetN(v int64) {
	capnp.Struct(s).SetUint64(0, uint64(v))
}

// PingPong_echoNum_Params_List is a list of PingPong_echoNum_Params.
type PingPong_echoNum_Params_List = capnp.StructList[PingPong_echoNum_Params]

// NewPingPong_echoNum_Params creates a new list of PingPong_echoNum_Params.
func NewPingPong_echoNum_Params_List(s *capnp.Segment, sz int32) (PingPong_echoNum_Params_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz)
	return capnp.StructList[PingPong_echoNum_Params](l), err
}

// PingPong_echoNum_Params_Future is a wrapper for a PingPong_echoNum_Params promised by a client call.
type PingPong_echoNum_Params_Future struct{ *capnp.Future }

func (f PingPong_echoNum_Params_Future) Struct() (PingPong_echoNum_Params, error) {
	p, err := f.Future.Ptr()
	return PingPong_echoNum_Params(p.Struct()), err
}

type PingPong_echoNum_Results capnp.Struct

// PingPong_echoNum_Results_TypeID is the unique identifier for the type PingPong_echoNum_Results.
const PingPong_echoNum_Results_TypeID = 0x85ddfd96db252600

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

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

func ReadRootPingPong_echoNum_Results(msg *capnp.Message) (PingPong_echoNum_Results, error) {
	root, err := msg.Root()
	return PingPong_echoNum_Results(root.Struct()), err
}

func (s PingPong_echoNum_Results) String() string {
	str, _ := text.Marshal(0x85ddfd96db252600, capnp.Struct(s))
	return str
}

func (s PingPong_echoNum_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (PingPong_echoNum_Results) DecodeFromPtr(p capnp.Ptr) PingPong_echoNum_Results {
	return PingPong_echoNum_Results(capnp.Struct{}.DecodeFromPtr(p))
}

func (s PingPong_echoNum_Results) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s PingPong_echoNum_Results) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s PingPong_echoNum_Results) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s PingPong_echoNum_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s PingPong_echoNum_Results) N() int64 {
	return int64(capnp.Struct(s).Uint64(0))
}

func (s PingPong_echoNum_Results) SetN(v int64) {
	capnp.Struct(s).SetUint64(0, uint64(v))
}

// PingPong_echoNum_Results_List is a list of PingPong_echoNum_Results.
type PingPong_echoNum_Results_List = capnp.StructList[PingPong_echoNum_Results]

// NewPingPong_echoNum_Results creates a new list of PingPong_echoNum_Results.
func NewPingPong_echoNum_Results_List(s *capnp.Segment, sz int32) (PingPong_echoNum_Results_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz)
	return capnp.StructList[PingPong_echoNum_Results](l), err
}

// PingPong_echoNum_Results_Future is a wrapper for a PingPong_echoNum_Results promised by a client call.
type PingPong_echoNum_Results_Future struct{ *capnp.Future }

func (f PingPong_echoNum_Results_Future) Struct() (PingPong_echoNum_Results, error) {
	p, err := f.Future.Ptr()
	return PingPong_echoNum_Results(p.Struct()), err
}

type StreamTest capnp.Client

// StreamTest_TypeID is the unique identifier for the type StreamTest.
const StreamTest_TypeID = 0xbb3ca85b01eea465

func (c StreamTest) Push(ctx context.Context, params func(StreamTest_push_Params) error) error {
	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xbb3ca85b01eea465,
			MethodID:      0,
			InterfaceName: "test.capnp:StreamTest",
			MethodName:    "push",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(StreamTest_push_Params(s)) }
	}

	return capnp.Client(c).SendStreamCall(ctx, s)

}

func (c StreamTest) WaitStreaming() error {
	return capnp.Client(c).WaitStreaming()
}

// String returns a string that identifies this capability for debugging
// purposes.  Its format should not be depended on: in particular, it
// should not be used to compare clients.  Use IsSame to compare clients
// for equality.
func (c StreamTest) String() string {
	return "StreamTest(" + capnp.Client(c).String() + ")"
}

// AddRef creates a new Client that refers to the same capability as c.
// If c is nil or has resolved to null, then AddRef returns nil.
func (c StreamTest) AddRef() StreamTest {
	return StreamTest(capnp.Client(c).AddRef())
}

// Release releases a capability reference.  If this is the last
// reference to the capability, then the underlying resources associated
// with the capability will be released.
//
// Release will panic if c has already been released, but not if c is
// nil or resolved to null.
func (c StreamTest) Release() {
	capnp.Client(c).Release()
}

// Resolve blocks until the capability is fully resolved or the Context
// expires.
func (c StreamTest) Resolve(ctx context.Context) error {
	return capnp.Client(c).Resolve(ctx)
}

func (c StreamTest) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Client(c).EncodeAsPtr(seg)
}

func (StreamTest) DecodeFromPtr(p capnp.Ptr) StreamTest {
	return StreamTest(capnp.Client{}.DecodeFromPtr(p))
}

// IsValid reports whether c is a valid reference to a capability.
// A reference is invalid if it is nil, has resolved to null, or has
// been released.
func (c StreamTest) IsValid() bool {
	return capnp.Client(c).IsValid()
}

// IsSame reports whether c and other refer to a capability created by the
// same call to NewClient.  This can return false negatives if c or other
// are not fully resolved: use Resolve if this is an issue.  If either
// c or other are released, then IsSame panics.
func (c StreamTest) IsSame(other StreamTest) bool {
	return capnp.Client(c).IsSame(capnp.Client(other))
}

// Update the flowcontrol.FlowLimiter used to manage flow control for
// this client. This affects all future calls, but not calls already
// waiting to send. Passing nil sets the value to flowcontrol.NopLimiter,
// which is also the default.
func (c StreamTest) SetFlowLimiter(lim fc.FlowLimiter) {
	capnp.Client(c).SetFlowLimiter(lim)
}

// Get the current flowcontrol.FlowLimiter used to manage flow control
// for this client.
func (c StreamTest) GetFlowLimiter() fc.FlowLimiter {
	return capnp.Client(c).GetFlowLimiter()
}

// A StreamTest_Server is a StreamTest with a local implementation.
type StreamTest_Server interface {
	Push(context.Context, StreamTest_push) error
}

// StreamTest_NewServer creates a new Server from an implementation of StreamTest_Server.
func StreamTest_NewServer(s StreamTest_Server) *server.Server {
	c, _ := s.(server.Shutdowner)
	return server.New(StreamTest_Methods(nil, s), s, c)
}

// StreamTest_ServerToClient creates a new Client from an implementation of StreamTest_Server.
// The caller is responsible for calling Release on the returned Client.
func StreamTest_ServerToClient(s StreamTest_Server) StreamTest {
	return StreamTest(capnp.NewClient(StreamTest_NewServer(s)))
}

// StreamTest_Methods appends Methods to a slice that invoke the methods on s.
// This can be used to create a more complicated Server.
func StreamTest_Methods(methods []server.Method, s StreamTest_Server) []server.Method {
	if cap(methods) == 0 {
		methods = make([]server.Method, 0, 1)
	}

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xbb3ca85b01eea465,
			MethodID:      0,
			InterfaceName: "test.capnp:StreamTest",
			MethodName:    "push",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.Push(ctx, StreamTest_push{call})
		},
	})

	return methods
}

// StreamTest_push holds the state for a server call to StreamTest.push.
// See server.Call for documentation.
type StreamTest_push struct {
	*server.Call
}

// Args returns the call's arguments.
func (c StreamTest_push) Args() StreamTest_push_Params {
	return StreamTest_push_Params(c.Call.Args())
}

// AllocResults allocates the results struct.
func (c StreamTest_push) AllocResults() (stream.StreamResult, error) {
	r, err := c.Call.AllocResults(capnp.ObjectSize{DataSize: 0, PointerCount: 0})
	return stream.StreamResult(r), err
}

// StreamTest_List is a list of StreamTest.
type StreamTest_List = capnp.CapList[StreamTest]

// NewStreamTest creates a new list of StreamTest.
func NewStreamTest_List(s *capnp.Segment, sz int32) (StreamTest_List, error) {
	l, err := capnp.NewPointerList(s, sz)
	return capnp.CapList[StreamTest](l), err
}

type StreamTest_push_Params capnp.Struct

// StreamTest_push_Params_TypeID is the unique identifier for the type StreamTest_push_Params.
const StreamTest_push_Params_TypeID = 0xf838dca6c8721bdb

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

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

func ReadRootStreamTest_push_Params(msg *capnp.Message) (StreamTest_push_Params, error) {
	root, err := msg.Root()
	return StreamTest_push_Params(root.Struct()), err
}

func (s StreamTest_push_Params) String() string {
	str, _ := text.Marshal(0xf838dca6c8721bdb, capnp.Struct(s))
	return str
}

func (s StreamTest_push_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (StreamTest_push_Params) DecodeFromPtr(p capnp.Ptr) StreamTest_push_Params {
	return StreamTest_push_Params(capnp.Struct{}.DecodeFromPtr(p))
}

func (s StreamTest_push_Params) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s StreamTest_push_Params) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s StreamTest_push_Params) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s StreamTest_push_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s StreamTest_push_Params) Data() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return []byte(p.Data()), err
}

func (s StreamTest_push_Params) HasData() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s StreamTest_push_Params) SetData(v []byte) error {
	return capnp.Struct(s).SetData(0, v)
}

// StreamTest_push_Params_List is a list of StreamTest_push_Params.
type StreamTest_push_Params_List = capnp.StructList[StreamTest_push_Params]

// NewStreamTest_push_Params creates a new list of StreamTest_push_Params.
func NewStreamTest_push_Params_List(s *capnp.Segment, sz int32) (StreamTest_push_Params_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return capnp.StructList[StreamTest_push_Params](l), err
}

// StreamTest_push_Params_Future is a wrapper for a StreamTest_push_Params promised by a client call.
type StreamTest_push_Params_Future struct{ *capnp.Future }

func (f StreamTest_push_Params_Future) Struct() (StreamTest_push_Params, error) {
	p, err := f.Future.Ptr()
	return StreamTest_push_Params(p.Struct()), err
}

type CapArgsTest capnp.Client

// CapArgsTest_TypeID is the unique identifier for the type CapArgsTest.
const CapArgsTest_TypeID = 0xb86bce7f916a10cc

func (c CapArgsTest) Call(ctx context.Context, params func(CapArgsTest_call_Params) error) (CapArgsTest_call_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb86bce7f916a10cc,
			MethodID:      0,
			InterfaceName: "test.capnp:CapArgsTest",
			MethodName:    "call",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(CapArgsTest_call_Params(s)) }
	}

	ans, release := capnp.Client(c).SendCall(ctx, s)
	return CapArgsTest_call_Results_Future{Future: ans.Future()}, release

}

func (c CapArgsTest) Self(ctx context.Context, params func(CapArgsTest_self_Params) error) (CapArgsTest_self_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb86bce7f916a10cc,
			MethodID:      1,
			InterfaceName: "test.capnp:CapArgsTest",
			MethodName:    "self",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
		s.PlaceArgs = func(s capnp.Struct) error { return params(CapArgsTest_self_Params(s)) }
	}

	ans, release := capnp.Client(c).SendCall(ctx, s)
	return CapArgsTest_self_Results_Future{Future: ans.Future()}, release

}

func (c CapArgsTest) WaitStreaming() error {
	return capnp.Client(c).WaitStreaming()
}

// String returns a string that identifies this capability for debugging
// purposes.  Its format should not be depended on: in particular, it
// should not be used to compare clients.  Use IsSame to compare clients
// for equality.
func (c CapArgsTest) String() string {
	return "CapArgsTest(" + capnp.Client(c).String() + ")"
}

// AddRef creates a new Client that refers to the same capability as c.
// If c is nil or has resolved to null, then AddRef returns nil.
func (c CapArgsTest) AddRef() CapArgsTest {
	return CapArgsTest(capnp.Client(c).AddRef())
}

// Release releases a capability reference.  If this is the last
// reference to the capability, then the underlying resources associated
// with the capability will be released.
//
// Release will panic if c has already been released, but not if c is
// nil or resolved to null.
func (c CapArgsTest) Release() {
	capnp.Client(c).Release()
}

// Resolve blocks until the capability is fully resolved or the Context
// expires.
func (c CapArgsTest) Resolve(ctx context.Context) error {
	return capnp.Client(c).Resolve(ctx)
}

func (c CapArgsTest) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Client(c).EncodeAsPtr(seg)
}

func (CapArgsTest) DecodeFromPtr(p capnp.Ptr) CapArgsTest {
	return CapArgsTest(capnp.Client{}.DecodeFromPtr(p))
}

// IsValid reports whether c is a valid reference to a capability.
// A reference is invalid if it is nil, has resolved to null, or has
// been released.
func (c CapArgsTest) IsValid() bool {
	return capnp.Client(c).IsValid()
}

// IsSame reports whether c and other refer to a capability created by the
// same call to NewClient.  This can return false negatives if c or other
// are not fully resolved: use Resolve if this is an issue.  If either
// c or other are released, then IsSame panics.
func (c CapArgsTest) IsSame(other CapArgsTest) bool {
	return capnp.Client(c).IsSame(capnp.Client(other))
}

// Update the flowcontrol.FlowLimiter used to manage flow control for
// this client. This affects all future calls, but not calls already
// waiting to send. Passing nil sets the value to flowcontrol.NopLimiter,
// which is also the default.
func (c CapArgsTest) SetFlowLimiter(lim fc.FlowLimiter) {
	capnp.Client(c).SetFlowLimiter(lim)
}

// Get the current flowcontrol.FlowLimiter used to manage flow control
// for this client.
func (c CapArgsTest) GetFlowLimiter() fc.FlowLimiter {
	return capnp.Client(c).GetFlowLimiter()
}

// A CapArgsTest_Server is a CapArgsTest with a local implementation.
type CapArgsTest_Server interface {
	Call(context.Context, CapArgsTest_call) error

	Self(context.Context, CapArgsTest_self) error
}

// CapArgsTest_NewServer creates a new Server from an implementation of CapArgsTest_Server.
func CapArgsTest_NewServer(s CapArgsTest_Server) *server.Server {
	c, _ := s.(server.Shutdowner)
	return server.New(CapArgsTest_Methods(nil, s), s, c)
}

// CapArgsTest_ServerToClient creates a new Client from an implementation of CapArgsTest_Server.
// The caller is responsible for calling Release on the returned Client.
func CapArgsTest_ServerToClient(s CapArgsTest_Server) CapArgsTest {
	return CapArgsTest(capnp.NewClient(CapArgsTest_NewServer(s)))
}

// CapArgsTest_Methods appends Methods to a slice that invoke the methods on s.
// This can be used to create a more complicated Server.
func CapArgsTest_Methods(methods []server.Method, s CapArgsTest_Server) []server.Method {
	if cap(methods) == 0 {
		methods = make([]server.Method, 0, 2)
	}

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb86bce7f916a10cc,
			MethodID:      0,
			InterfaceName: "test.capnp:CapArgsTest",
			MethodName:    "call",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.Call(ctx, CapArgsTest_call{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb86bce7f916a10cc,
			MethodID:      1,
			InterfaceName: "test.capnp:CapArgsTest",
			MethodName:    "self",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.Self(ctx, CapArgsTest_self{call})
		},
	})

	return methods
}

// CapArgsTest_call holds the state for a server call to CapArgsTest.call.
// See server.Call for documentation.
type CapArgsTest_call struct {
	*server.Call
}

// Args returns the call's arguments.
func (c CapArgsTest_call) Args() CapArgsTest_call_Params {
	return CapArgsTest_call_Params(c.Call.Args())
}

// AllocResults allocates the results struct.
func (c CapArgsTest_call) AllocResults() (CapArgsTest_call_Results, error) {
	r, err := c.Call.AllocResults(capnp.ObjectSize{DataSize: 0, PointerCount: 0})
	return CapArgsTest_call_Results(r), err
}

// CapArgsTest_self holds the state for a server call to CapArgsTest.self.
// See server.Call for documentation.
type CapArgsTest_self struct {
	*server.Call
}

// Args returns the call's arguments.
func (c CapArgsTest_self) Args() CapArgsTest_self_Params {
	return CapArgsTest_self_Params(c.Call.Args())
}

// AllocResults allocates the results struct.
func (c CapArgsTest_self) AllocResults() (CapArgsTest_self_Results, error) {
	r, err := c.Call.AllocResults(capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return CapArgsTest_self_Results(r), err
}

// CapArgsTest_List is a list of CapArgsTest.
type CapArgsTest_List = capnp.CapList[CapArgsTest]

// NewCapArgsTest creates a new list of CapArgsTest.
func NewCapArgsTest_List(s *capnp.Segment, sz int32) (CapArgsTest_List, error) {
	l, err := capnp.NewPointerList(s, sz)
	return capnp.CapList[CapArgsTest](l), err
}

type CapArgsTest_call_Params capnp.Struct

// CapArgsTest_call_Params_TypeID is the unique identifier for the type CapArgsTest_call_Params.
const CapArgsTest_call_Params_TypeID = 0x80087e4e698768a2

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

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

func ReadRootCapArgsTest_call_Params(msg *capnp.Message) (CapArgsTest_call_Params, error) {
	root, err := msg.Root()
	return CapArgsTest_call_Params(root.Struct()), err
}

func (s CapArgsTest_call_Params) String() string {
	str, _ := text.Marshal(0x80087e4e698768a2, capnp.Struct(s))
	return str
}

func (s CapArgsTest_call_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (CapArgsTest_call_Params) DecodeFromPtr(p capnp.Ptr) CapArgsTest_call_Params {
	return CapArgsTest_call_Params(capnp.Struct{}.DecodeFromPtr(p))
}

func (s CapArgsTest_call_Params) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s CapArgsTest_call_Params) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s CapArgsTest_call_Params) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s CapArgsTest_call_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s CapArgsTest_call_Params) Cap() capnp.Client {
	p, _ := capnp.Struct(s).Ptr(0)
	return p.Interface().Client()
}

func (s CapArgsTest_call_Params) HasCap() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s CapArgsTest_call_Params) SetCap(c capnp.Client) error {
	if !c.IsValid() {
		return capnp.Struct(s).SetPtr(0, capnp.Ptr{})
	}
	seg := s.Segment()
	in := capnp.NewInterface(seg, seg.Message().CapTable().Add(c))
	return capnp.Struct(s).SetPtr(0, in.ToPtr())
}

// CapArgsTest_call_Params_List is a list of CapArgsTest_call_Params.
type CapArgsTest_call_Params_List = capnp.StructList[CapArgsTest_call_Params]

// NewCapArgsTest_call_Params creates a new list of CapArgsTest_call_Params.
func NewCapArgsTest_call_Params_List(s *capnp.Segment, sz int32) (CapArgsTest_call_Params_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return capnp.StructList[CapArgsTest_call_Params](l), err
}

// CapArgsTest_call_Params_Future is a wrapper for a CapArgsTest_call_Params promised by a client call.
type CapArgsTest_call_Params_Future struct{ *capnp.Future }

func (f CapArgsTest_call_Params_Future) Struct() (CapArgsTest_call_Params, error) {
	p, err := f.Future.Ptr()
	return CapArgsTest_call_Params(p.Struct()), err
}
func (p CapArgsTest_call_Params_Future) Cap() capnp.Client {
	return p.Future.Field(0, nil).Client()
}

type CapArgsTest_call_Results capnp.Struct

// CapArgsTest_call_Results_TypeID is the unique identifier for the type CapArgsTest_call_Results.
const CapArgsTest_call_Results_TypeID = 0x96fbc50dc2f0200d

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

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

func ReadRootCapArgsTest_call_Results(msg *capnp.Message) (CapArgsTest_call_Results, error) {
	root, err := msg.Root()
	return CapArgsTest_call_Results(root.Struct()), err
}

func (s CapArgsTest_call_Results) String() string {
	str, _ := text.Marshal(0x96fbc50dc2f0200d, capnp.Struct(s))
	return str
}

func (s CapArgsTest_call_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (CapArgsTest_call_Results) DecodeFromPtr(p capnp.Ptr) CapArgsTest_call_Results {
	return CapArgsTest_call_Results(capnp.Struct{}.DecodeFromPtr(p))
}

func (s CapArgsTest_call_Results) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s CapArgsTest_call_Results) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s CapArgsTest_call_Results) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s CapArgsTest_call_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}

// CapArgsTest_call_Results_List is a list of CapArgsTest_call_Results.
type CapArgsTest_call_Results_List = capnp.StructList[CapArgsTest_call_Results]

// NewCapArgsTest_call_Results creates a new list of CapArgsTest_call_Results.
func NewCapArgsTest_call_Results_List(s *capnp.Segment, sz int32) (CapArgsTest_call_Results_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
	return capnp.StructList[CapArgsTest_call_Results](l), err
}

// CapArgsTest_call_Results_Future is a wrapper for a CapArgsTest_call_Results promised by a client call.
type CapArgsTest_call_Results_Future struct{ *capnp.Future }

func (f CapArgsTest_call_Results_Future) Struct() (CapArgsTest_call_Results, error) {
	p, err := f.Future.Ptr()
	return CapArgsTest_call_Results(p.Struct()), err
}

type CapArgsTest_self_Params capnp.Struct

// CapArgsTest_self_Params_TypeID is the unique identifier for the type CapArgsTest_self_Params.
const CapArgsTest_self_Params_TypeID = 0xe2553e5a663abb7d

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

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

func ReadRootCapArgsTest_self_Params(msg *capnp.Message) (CapArgsTest_self_Params, error) {
	root, err := msg.Root()
	return CapArgsTest_self_Params(root.Struct()), err
}

func (s CapArgsTest_self_Params) String() string {
	str, _ := text.Marshal(0xe2553e5a663abb7d, capnp.Struct(s))
	return str
}

func (s CapArgsTest_self_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (CapArgsTest_self_Params) DecodeFromPtr(p capnp.Ptr) CapArgsTest_self_Params {
	return CapArgsTest_self_Params(capnp.Struct{}.DecodeFromPtr(p))
}

func (s CapArgsTest_self_Params) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s CapArgsTest_self_Params) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s CapArgsTest_self_Params) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s CapArgsTest_self_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}

// CapArgsTest_self_Params_List is a list of CapArgsTest_self_Params.
type CapArgsTest_self_Params_List = capnp.StructList[CapArgsTest_self_Params]

// NewCapArgsTest_self_Params creates a new list of CapArgsTest_self_Params.
func NewCapArgsTest_self_Params_List(s *capnp.Segment, sz int32) (CapArgsTest_self_Params_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
	return capnp.StructList[CapArgsTest_self_Params](l), err
}

// CapArgsTest_self_Params_Future is a wrapper for a CapArgsTest_self_Params promised by a client call.
type CapArgsTest_self_Params_Future struct{ *capnp.Future }

func (f CapArgsTest_self_Params_Future) Struct() (CapArgsTest_self_Params, error) {
	p, err := f.Future.Ptr()
	return CapArgsTest_self_Params(p.Struct()), err
}

type CapArgsTest_self_Results capnp.Struct

// CapArgsTest_self_Results_TypeID is the unique identifier for the type CapArgsTest_self_Results.
const CapArgsTest_self_Results_TypeID = 0x9746cc05cbff1132

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

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

func ReadRootCapArgsTest_self_Results(msg *capnp.Message) (CapArgsTest_self_Results, error) {
	root, err := msg.Root()
	return CapArgsTest_self_Results(root.Struct()), err
}

func (s CapArgsTest_self_Results) String() string {
	str, _ := text.Marshal(0x9746cc05cbff1132, capnp.Struct(s))
	return str
}

func (s CapArgsTest_self_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (CapArgsTest_self_Results) DecodeFromPtr(p capnp.Ptr) CapArgsTest_self_Results {
	return CapArgsTest_self_Results(capnp.Struct{}.DecodeFromPtr(p))
}

func (s CapArgsTest_self_Results) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s CapArgsTest_self_Results) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s CapArgsTest_self_Results) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s CapArgsTest_self_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s CapArgsTest_self_Results) Self() CapArgsTest {
	p, _ := capnp.Struct(s).Ptr(0)
	return CapArgsTest(p.Interface().Client())
}

func (s CapArgsTest_self_Results) HasSelf() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s CapArgsTest_self_Results) SetSelf(v CapArgsTest) error {
	if !v.IsValid() {
		return capnp.Struct(s).SetPtr(0, capnp.Ptr{})
	}
	seg := s.Segment()
	in := capnp.NewInterface(seg, seg.Message().CapTable().Add(capnp.Client(v)))
	return capnp.Struct(s).SetPtr(0, in.ToPtr())
}

// CapArgsTest_self_Results_List is a list of CapArgsTest_self_Results.
type CapArgsTest_self_Results_List = capnp.StructList[CapArgsTest_self_Results]

// NewCapArgsTest_self_Results creates a new list of CapArgsTest_self_Results.
func NewCapArgsTest_self_Results_List(s *capnp.Segment, sz int32) (CapArgsTest_self_Results_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return capnp.StructList[CapArgsTest_self_Results](l), err
}

// CapArgsTest_self_Results_Future is a wrapper for a CapArgsTest_self_Results promised by a client call.
type CapArgsTest_self_Results_Future struct{ *capnp.Future }

func (f CapArgsTest_self_Results_Future) Struct() (CapArgsTest_self_Results, error) {
	p, err := f.Future.Ptr()
	return CapArgsTest_self_Results(p.Struct()), err
}
func (p CapArgsTest_self_Results_Future) Self() CapArgsTest {
	return CapArgsTest(p.Future.Field(0, nil).Client())
}

type PingPongProvider capnp.Client

// PingPongProvider_TypeID is the unique identifier for the type PingPongProvider.
const PingPongProvider_TypeID = 0x95b6142577e93239

func (c PingPongProvider) PingPong(ctx context.Context, params func(PingPongProvider_pingPong_Params) error) (PingPongProvider_pingPong_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0x95b6142577e93239,
			MethodID:      0,
			InterfaceName: "test.capnp:PingPongProvider",
			MethodName:    "pingPong",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
		s.PlaceArgs = func(s capnp.Struct) error { return params(PingPongProvider_pingPong_Params(s)) }
	}

	ans, release := capnp.Client(c).SendCall(ctx, s)
	return PingPongProvider_pingPong_Results_Future{Future: ans.Future()}, release

}

func (c PingPongProvider) WaitStreaming() error {
	return capnp.Client(c).WaitStreaming()
}

// String returns a string that identifies this capability for debugging
// purposes.  Its format should not be depended on: in particular, it
// should not be used to compare clients.  Use IsSame to compare clients
// for equality.
func (c PingPongProvider) String() string {
	return "PingPongProvider(" + capnp.Client(c).String() + ")"
}

// AddRef creates a new Client that refers to the same capability as c.
// If c is nil or has resolved to null, then AddRef returns nil.
func (c PingPongProvider) AddRef() PingPongProvider {
	return PingPongProvider(capnp.Client(c).AddRef())
}

// Release releases a capability reference.  If this is the last
// reference to the capability, then the underlying resources associated
// with the capability will be released.
//
// Release will panic if c has already been released, but not if c is
// nil or resolved to null.
func (c PingPongProvider) Release() {
	capnp.Client(c).Release()
}

// Resolve blocks until the capability is fully resolved or the Context
// expires.
func (c PingPongProvider) Resolve(ctx context.Context) error {
	return capnp.Client(c).Resolve(ctx)
}

func (c PingPongProvider) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Client(c).EncodeAsPtr(seg)
}

func (PingPongProvider) DecodeFromPtr(p capnp.Ptr) PingPongProvider {
	return PingPongProvider(capnp.Client{}.DecodeFromPtr(p))
}

// IsValid reports whether c is a valid reference to a capability.
// A reference is invalid if it is nil, has resolved to null, or has
// been released.
func (c PingPongProvider) IsValid() bool {
	return capnp.Client(c).IsValid()
}

// IsSame reports whether c and other refer to a capability created by the
// same call to NewClient.  This can return false negatives if c or other
// are not fully resolved: use Resolve if this is an issue.  If either
// c or other are released, then IsSame panics.
func (c PingPongProvider) IsSame(other PingPongProvider) bool {
	return capnp.Client(c).IsSame(capnp.Client(other))
}

// Update the flowcontrol.FlowLimiter used to manage flow control for
// this client. This affects all future calls, but not calls already
// waiting to send. Passing nil sets the value to flowcontrol.NopLimiter,
// which is also the default.
func (c PingPongProvider) SetFlowLimiter(lim fc.FlowLimiter) {
	capnp.Client(c).SetFlowLimiter(lim)
}

// Get the current flowcontrol.FlowLimiter used to manage flow control
// for this client.
func (c PingPongProvider) GetFlowLimiter() fc.FlowLimiter {
	return capnp.Client(c).GetFlowLimiter()
}

// A PingPongProvider_Server is a PingPongProvider with a local implementation.
type PingPongProvider_Server interface {
	PingPong(context.Context, PingPongProvider_pingPong) error
}

// PingPongProvider_NewServer creates a new Server from an implementation of PingPongProvider_Server.
func PingPongProvider_NewServer(s PingPongProvider_Server) *server.Server {
	c, _ := s.(server.Shutdowner)
	return server.New(PingPongProvider_Methods(nil, s), s, c)
}

// PingPongProvider_ServerToClient creates a new Client from an implementation of PingPongProvider_Server.
// The caller is responsible for calling Release on the returned Client.
func PingPongProvider_ServerToClient(s PingPongProvider_Server) PingPongProvider {
	return PingPongProvider(capnp.NewClient(PingPongProvider_NewServer(s)))
}

// PingPongProvider_Methods appends Methods to a slice that invoke the methods on s.
// This can be used to create a more complicated Server.
func PingPongProvider_Methods(methods []server.Method, s PingPongProvider_Server) []server.Method {
	if cap(methods) == 0 {
		methods = make([]server.Method, 0, 1)
	}

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0x95b6142577e93239,
			MethodID:      0,
			InterfaceName: "test.capnp:PingPongProvider",
			MethodName:    "pingPong",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.PingPong(ctx, PingPongProvider_pingPong{call})
		},
	})

	return methods
}

// PingPongProvider_pingPong holds the state for a server call to PingPongProvider.pingPong.
// See server.Call for documentation.
type PingPongProvider_pingPong struct {
	*server.Call
}

// Args returns the call's arguments.
func (c PingPongProvider_pingPong) Args() PingPongProvider_pingPong_Params {
	return PingPongProvider_pingPong_Params(c.Call.Args())
}

// AllocResults allocates the results struct.
func (c PingPongProvider_pingPong) AllocResults() (PingPongProvider_pingPong_Results, error) {
	r, err := c.Call.AllocResults(capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return PingPongProvider_pingPong_Results(r), err
}

// PingPongProvider_List is a list of PingPongProvider.
type PingPongProvider_List = capnp.CapList[PingPongProvider]

// NewPingPongProvider creates a new list of PingPongProvider.
func NewPingPongProvider_List(s *capnp.Segment, sz int32) (PingPongProvider_List, error) {
	l, err := capnp.NewPointerList(s, sz)
	return capnp.CapList[PingPongProvider](l), err
}

type PingPongProvider_pingPong_Params capnp.Struct

// PingPongProvider_pingPong_Params_TypeID is the unique identifier for the type PingPongProvider_pingPong_Params.
const PingPongProvider_pingPong_Params_TypeID = 0xd4e835c17f1ef32c

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

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

func ReadRootPingPongProvider_pingPong_Params(msg *capnp.Message) (PingPongProvider_pingPong_Params, error) {
	root, err := msg.Root()
	return PingPongProvider_pingPong_Params(root.Struct()), err
}

func (s PingPongProvider_pingPong_Params) String() string {
	str, _ := text.Marshal(0xd4e835c17f1ef32c, capnp.Struct(s))
	return str
}

func (s PingPongProvider_pingPong_Params) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (PingPongProvider_pingPong_Params) DecodeFromPtr(p capnp.Ptr) PingPongProvider_pingPong_Params {
	return PingPongProvider_pingPong_Params(capnp.Struct{}.DecodeFromPtr(p))
}

func (s PingPongProvider_pingPong_Params) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s PingPongProvider_pingPong_Params) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s PingPongProvider_pingPong_Params) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s PingPongProvider_pingPong_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}

// PingPongProvider_pingPong_Params_List is a list of PingPongProvider_pingPong_Params.
type PingPongProvider_pingPong_Params_List = capnp.StructList[PingPongProvider_pingPong_Params]

// NewPingPongProvider_pingPong_Params creates a new list of PingPongProvider_pingPong_Params.
func NewPingPongProvider_pingPong_Params_List(s *capnp.Segment, sz int32) (PingPongProvider_pingPong_Params_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
	return capnp.StructList[PingPongProvider_pingPong_Params](l), err
}

// PingPongProvider_pingPong_Params_Future is a wrapper for a PingPongProvider_pingPong_Params promised by a client call.
type PingPongProvider_pingPong_Params_Future struct{ *capnp.Future }

func (f PingPongProvider_pingPong_Params_Future) Struct() (PingPongProvider_pingPong_Params, error) {
	p, err := f.Future.Ptr()
	return PingPongProvider_pingPong_Params(p.Struct()), err
}

type PingPongProvider_pingPong_Results capnp.Struct

// PingPongProvider_pingPong_Results_TypeID is the unique identifier for the type PingPongProvider_pingPong_Results.
const PingPongProvider_pingPong_Results_TypeID = 0xf269473b6db8d0eb

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

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

func ReadRootPingPongProvider_pingPong_Results(msg *capnp.Message) (PingPongProvider_pingPong_Results, error) {
	root, err := msg.Root()
	return PingPongProvider_pingPong_Results(root.Struct()), err
}

func (s PingPongProvider_pingPong_Results) String() string {
	str, _ := text.Marshal(0xf269473b6db8d0eb, capnp.Struct(s))
	return str
}

func (s PingPongProvider_pingPong_Results) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (PingPongProvider_pingPong_Results) DecodeFromPtr(p capnp.Ptr) PingPongProvider_pingPong_Results {
	return PingPongProvider_pingPong_Results(capnp.Struct{}.DecodeFromPtr(p))
}

func (s PingPongProvider_pingPong_Results) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s PingPongProvider_pingPong_Results) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s PingPongProvider_pingPong_Results) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s PingPongProvider_pingPong_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s PingPongProvider_pingPong_Results) PingPong() PingPong {
	p, _ := capnp.Struct(s).Ptr(0)
	return PingPong(p.Interface().Client())
}

func (s PingPongProvider_pingPong_Results) HasPingPong() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s PingPongProvider_pingPong_Results) SetPingPong(v PingPong) error {
	if !v.IsValid() {
		return capnp.Struct(s).SetPtr(0, capnp.Ptr{})
	}
	seg := s.Segment()
	in := capnp.NewInterface(seg, seg.Message().CapTable().Add(capnp.Client(v)))
	return capnp.Struct(s).SetPtr(0, in.ToPtr())
}

// PingPongProvider_pingPong_Results_List is a list of PingPongProvider_pingPong_Results.
type PingPongProvider_pingPong_Results_List = capnp.StructList[PingPongProvider_pingPong_Results]

// NewPingPongProvider_pingPong_Results creates a new list of PingPongProvider_pingPong_Results.
func NewPingPongProvider_pingPong_Results_List(s *capnp.Segment, sz int32) (PingPongProvider_pingPong_Results_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return capnp.StructList[PingPongProvider_pingPong_Results](l), err
}

// PingPongProvider_pingPong_Results_Future is a wrapper for a PingPongProvider_pingPong_Results promised by a client call.
type PingPongProvider_pingPong_Results_Future struct{ *capnp.Future }

func (f PingPongProvider_pingPong_Results_Future) Struct() (PingPongProvider_pingPong_Results, error) {
	p, err := f.Future.Ptr()
	return PingPongProvider_pingPong_Results(p.Struct()), err
}
func (p PingPongProvider_pingPong_Results_Future) PingPong() PingPong {
	return PingPong(p.Future.Field(0, nil).Client())
}

const schema_ef12a34b9807e19c = "x\xda|T]h#U\x14>g\xe6^'E\xc7" +
	"x3E\xcd\xbau\xed\xb2\xf1gY\x83\xe9RX\xeb" +
	"O\xbb\x8a\x06+\x94\x99\xaa\x0f*\xe2\x8e\xcdl\x9a5" +
	"I\x87\xcc\xc4\xa2\xa2\xf5eY\xf4mY\xdc\xd5E\x14" +
	"W\x11}\xac\xa0VKA\x8bJ\xd5V\x14\x8a>\xb4" +
	"E-\x08U\xa1V}\xa9\x88\x8e\xdc;\xb9\xc9$i" +
	"\xf36\xcc\xfd\xeew\xbe\xef\x9c\xef\x9e\x9bnP\x86H" +
	"F\x7f-\x06\x8a\x95\xa3\x17\x05\x17\xc6O\x15F\x9e\x8d" +
	"=\x07\xec\x0a\x04\xa0\xa8\x01\x1c\xee'{\x10\xd0\xb8\x8d" +
	"\x0c\x02\xfewmj\xe5\xec\xbfk'\xadnD\x00\xc2" +
	"\x8f\x1f!\xfb\xf9\xb1\xc3\x8f\x83\xa5c\xc7\xf4\xcf\xf7^" +
	"\x7f\x06X\xb2~\xff$\x19\xe5\x80\xd3\x02ps\xdf/" +
	"\x93\xa9\xee\xf7_\x04v\xb1\x1a\xbc\xf2\x93\xf6\xd2\xbdo" +
	"$~\x07@c\x9a\xac\x1bs\x9c\xd0\xf8\x90d\x8d\x9f" +
	"\xf9W\xa0_\xb35\xaf\x7f\xf6\xcf\xd9P\x8d\xa8\xb6\xc4" +
	"\xab\x91\xa0\x8f\x05_\xd1\xc5\xbb\xcfEu\xbe\x17\x0a\x99" +
	"\x13u\x9e\x9f\x9f\x99\xbc1v\xdd\xf9P\x88\xb8\xbaF" +
	"\x86\xf9\xd5\xc5\xcbN\x9c\x9e\xfa\xfa\xf1\x996\x05_\x90" +
	"\x8f\x8co\x85\x82%r\xca\xe8\xa1\\\x81\xf3\xe6&>" +
	"\xfc\xf6\xad\xb3m`J\xdf5t\x0e1\xbah\xd6\xc8" +
	"\x08\xf0\xd1\x0f\x0e=}fdz\xa1\x0d\x9c\xa4/\x18" +
	"\xbd\x02\xdcC\xb5\x1a\xf3\xa1\xbf\xae\x9e\xfa\xa4\x7fc\x19" +
	"\xd8^)\x90\xd2\xc7\xb8\xc0\xde\xae\x1f^}\xe7\xc7s" +
	"\xdfC\xa4\xc9\x7f\x843\xf8[x{fv\xe0\xf8C" +
	"\xb7?\xb0\x1eiK\x92\xee\xe1W/\xddx}\xf5\xbb" +
	"\xe5#\xbf\xb6)@\xfaeDn\xbfP\xf0\xd4\xe6\xf6" +
	"\xbc\xff)\xd9j\x03\xf7\xd0\x0bFJ\x80{i\xd6\xb8" +
	"G\x80\x7f\xfbf\xa6tK\xb6\xf0g(7lx\x86" +
	"\x9e\x10\xc1\xa0\\\xd4\xcaU\x95\x85\xb7V\x8fl\x03\xbb" +
	"\xbc\x0e\xb0i\x82\x03\x0at\x10\x1e\x0c|\xc7\xf3\xd3c" +
	"\xb6\xab\x96\xdd\x81;m\xf7h%\xef\xdd\x1f\xfe*\x16" +
	"\x0f\x98v\xc5VK\x9eET\x02@\x10\x80\xe9\xfb\x01" +
	"\xac\x98\x8aV\xb7\x82\xda\x98\xedb\x82\xa8\x80\x98\x00l" +
	"b2\x0b\xe5\xbc9Q\xce\xa7\x9d\xb1\xf1\x89\x91j\xe9" +
	"\xc0\xa8\xe3U\xb5\xa2\xdfD\x95hPa\x19)(H" +
	"#4\xa4\xec\x0e\xdcUr\xfd'\xcd\xca\xc4\x13\x85\x9c" +
	"SI\xe7\x1d_\xfc\x10dE\x1f\x9b\xc8\xfa\x1ad\xfb" +
	"\x1c\x8eB\xd6\x98< \xb2\x08\xb5\x12Q(\xd8\xb5\x9c" +
	"S1\x11-\xa2\xd2H\x06Pv\x97\xb1aPX\x97" +
	"\x16\xb8\xb5K\x000\x84&b\xe7\xeeI\xcf\xbb\xa2<" +
	"\xa7x|\xc7\xce\x1cl\x98\x89s\x10\xb2\xc6\xfbh\xf1" +
	"\xd2\xa1M|z%\x0f\xa0\x8eEY\x7f0\x14\xc0-" +
	"\xc7\x84e\xb9`P\xbem\x969\x08\x0aKi\xd8\xc8" +
	"5\xca\xd7\xcd\x92\xfcL\xd7\xe2\xdc\xe5P\xa8\xb0\xb9\x1d" +
	"\xbc\xd0}~\xc5\xb1\xf7\x95d\x9d\xb0\xb52\x8eX\x9e" +
	"\xfex\xf2\xf0\xf9G_f\x8csQ-\xeeV\xbd\xf1" +
	"v\x12a\x04\xc0D4U\x1a=$\xad#\xe4\xce\xe5" +
	"x\xb8s\xcd.y\x9d#\xb9C\xb8;'r\xc7\xf1" +
	"\xd5X\x9a\xb2\xd54\x0f\xa1\xbef_\xae?\x94\x0b\xb9" +
	"\x9e,9\xb4\xb6d\xa1\x94\xaeq\xa7u&\xb9\x8d\x10" +
	"j\xab\x9f\xb1;D#\xa7j\xf6\x9aY:\xb7k\xd4" +
	"\xf1\xe2\xd5\x96\x08\x0e\x03X\x97\xa8h]\xa9`4\xf6" +
	"\xc8\x1a\x0b\xaa%\x89\xaa\x1c\xba\x98y\x9a\x0f4\x8c " +
	"\xee\x9a\xed\x9c\xed\xdb\xa8\x83\x82:\xe0\xff\x01\x00\x00\xff" +
	"\xff\xe4@\xf6j"

func RegisterSchema(reg *schemas.Registry) {
	reg.Register(&schemas.Schema{
		String: schema_ef12a34b9807e19c,
		Nodes: []uint64{
			0x80087e4e698768a2,
			0x85ddfd96db252600,
			0x93281cc60d6060cd,
			0x95b6142577e93239,
			0x96fbc50dc2f0200d,
			0x9746cc05cbff1132,
			0x9a27082d77b8c289,
			0xb86bce7f916a10cc,
			0xbb3ca85b01eea465,
			0xc8b14e937b2cb741,
			0xd4e835c17f1ef32c,
			0xd797e0a99edf0921,
			0xe2553e5a663abb7d,
			0xea38d4d6dca1e80e,
			0xf004c474c2f8ee7a,
			0xf269473b6db8d0eb,
			0xf838dca6c8721bdb,
		},
		Compressed: true,
	})
}
