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

package proto

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"
	context "context"
)

type Conmon capnp.Client

// Conmon_TypeID is the unique identifier for the type Conmon.
const Conmon_TypeID = 0xb737e899dd6633f1

func (c Conmon) Version(ctx context.Context, params func(Conmon_version_Params) error) (Conmon_version_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      0,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "version",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_version_Params(s)) }
	}

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

}

func (c Conmon) CreateContainer(ctx context.Context, params func(Conmon_createContainer_Params) error) (Conmon_createContainer_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      1,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "createContainer",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_createContainer_Params(s)) }
	}

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

}

func (c Conmon) ExecSyncContainer(ctx context.Context, params func(Conmon_execSyncContainer_Params) error) (Conmon_execSyncContainer_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      2,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "execSyncContainer",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_execSyncContainer_Params(s)) }
	}

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

}

func (c Conmon) AttachContainer(ctx context.Context, params func(Conmon_attachContainer_Params) error) (Conmon_attachContainer_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      3,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "attachContainer",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_attachContainer_Params(s)) }
	}

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

}

func (c Conmon) ReopenLogContainer(ctx context.Context, params func(Conmon_reopenLogContainer_Params) error) (Conmon_reopenLogContainer_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      4,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "reopenLogContainer",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_reopenLogContainer_Params(s)) }
	}

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

}

func (c Conmon) SetWindowSizeContainer(ctx context.Context, params func(Conmon_setWindowSizeContainer_Params) error) (Conmon_setWindowSizeContainer_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      5,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "setWindowSizeContainer",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_setWindowSizeContainer_Params(s)) }
	}

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

}

func (c Conmon) CreateNamespaces(ctx context.Context, params func(Conmon_createNamespaces_Params) error) (Conmon_createNamespaces_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      6,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "createNamespaces",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_createNamespaces_Params(s)) }
	}

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

}

func (c Conmon) StartFdSocket(ctx context.Context, params func(Conmon_startFdSocket_Params) error) (Conmon_startFdSocket_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      7,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "startFdSocket",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_startFdSocket_Params(s)) }
	}

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

}

func (c Conmon) ServeExecContainer(ctx context.Context, params func(Conmon_serveExecContainer_Params) error) (Conmon_serveExecContainer_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      8,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "serveExecContainer",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_serveExecContainer_Params(s)) }
	}

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

}

func (c Conmon) ServeAttachContainer(ctx context.Context, params func(Conmon_serveAttachContainer_Params) error) (Conmon_serveAttachContainer_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      9,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "serveAttachContainer",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_serveAttachContainer_Params(s)) }
	}

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

}

func (c Conmon) ServePortForwardContainer(ctx context.Context, params func(Conmon_servePortForwardContainer_Params) error) (Conmon_servePortForwardContainer_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      10,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "servePortForwardContainer",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(Conmon_servePortForwardContainer_Params(s)) }
	}

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

}

func (c Conmon) 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 Conmon) String() string {
	return "Conmon(" + 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 Conmon) AddRef() Conmon {
	return Conmon(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 Conmon) Release() {
	capnp.Client(c).Release()
}

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

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

func (Conmon) DecodeFromPtr(p capnp.Ptr) Conmon {
	return Conmon(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 Conmon) 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 Conmon) IsSame(other Conmon) 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 Conmon) SetFlowLimiter(lim fc.FlowLimiter) {
	capnp.Client(c).SetFlowLimiter(lim)
}

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

// A Conmon_Server is a Conmon with a local implementation.
type Conmon_Server interface {
	Version(context.Context, Conmon_version) error

	CreateContainer(context.Context, Conmon_createContainer) error

	ExecSyncContainer(context.Context, Conmon_execSyncContainer) error

	AttachContainer(context.Context, Conmon_attachContainer) error

	ReopenLogContainer(context.Context, Conmon_reopenLogContainer) error

	SetWindowSizeContainer(context.Context, Conmon_setWindowSizeContainer) error

	CreateNamespaces(context.Context, Conmon_createNamespaces) error

	StartFdSocket(context.Context, Conmon_startFdSocket) error

	ServeExecContainer(context.Context, Conmon_serveExecContainer) error

	ServeAttachContainer(context.Context, Conmon_serveAttachContainer) error

	ServePortForwardContainer(context.Context, Conmon_servePortForwardContainer) error
}

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

// Conmon_ServerToClient creates a new Client from an implementation of Conmon_Server.
// The caller is responsible for calling Release on the returned Client.
func Conmon_ServerToClient(s Conmon_Server) Conmon {
	return Conmon(capnp.NewClient(Conmon_NewServer(s)))
}

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

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      0,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "version",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.Version(ctx, Conmon_version{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      1,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "createContainer",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.CreateContainer(ctx, Conmon_createContainer{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      2,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "execSyncContainer",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.ExecSyncContainer(ctx, Conmon_execSyncContainer{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      3,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "attachContainer",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.AttachContainer(ctx, Conmon_attachContainer{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      4,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "reopenLogContainer",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.ReopenLogContainer(ctx, Conmon_reopenLogContainer{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      5,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "setWindowSizeContainer",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.SetWindowSizeContainer(ctx, Conmon_setWindowSizeContainer{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      6,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "createNamespaces",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.CreateNamespaces(ctx, Conmon_createNamespaces{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      7,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "startFdSocket",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.StartFdSocket(ctx, Conmon_startFdSocket{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      8,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "serveExecContainer",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.ServeExecContainer(ctx, Conmon_serveExecContainer{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      9,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "serveAttachContainer",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.ServeAttachContainer(ctx, Conmon_serveAttachContainer{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb737e899dd6633f1,
			MethodID:      10,
			InterfaceName: "internal/proto/conmon.capnp:Conmon",
			MethodName:    "servePortForwardContainer",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.ServePortForwardContainer(ctx, Conmon_servePortForwardContainer{call})
		},
	})

	return methods
}

// Conmon_version holds the state for a server call to Conmon.version.
// See server.Call for documentation.
type Conmon_version struct {
	*server.Call
}

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

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

// Conmon_createContainer holds the state for a server call to Conmon.createContainer.
// See server.Call for documentation.
type Conmon_createContainer struct {
	*server.Call
}

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

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

// Conmon_execSyncContainer holds the state for a server call to Conmon.execSyncContainer.
// See server.Call for documentation.
type Conmon_execSyncContainer struct {
	*server.Call
}

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

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

// Conmon_attachContainer holds the state for a server call to Conmon.attachContainer.
// See server.Call for documentation.
type Conmon_attachContainer struct {
	*server.Call
}

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

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

// Conmon_reopenLogContainer holds the state for a server call to Conmon.reopenLogContainer.
// See server.Call for documentation.
type Conmon_reopenLogContainer struct {
	*server.Call
}

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

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

// Conmon_setWindowSizeContainer holds the state for a server call to Conmon.setWindowSizeContainer.
// See server.Call for documentation.
type Conmon_setWindowSizeContainer struct {
	*server.Call
}

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

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

// Conmon_createNamespaces holds the state for a server call to Conmon.createNamespaces.
// See server.Call for documentation.
type Conmon_createNamespaces struct {
	*server.Call
}

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

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

// Conmon_startFdSocket holds the state for a server call to Conmon.startFdSocket.
// See server.Call for documentation.
type Conmon_startFdSocket struct {
	*server.Call
}

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

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

// Conmon_serveExecContainer holds the state for a server call to Conmon.serveExecContainer.
// See server.Call for documentation.
type Conmon_serveExecContainer struct {
	*server.Call
}

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

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

// Conmon_serveAttachContainer holds the state for a server call to Conmon.serveAttachContainer.
// See server.Call for documentation.
type Conmon_serveAttachContainer struct {
	*server.Call
}

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

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

// Conmon_servePortForwardContainer holds the state for a server call to Conmon.servePortForwardContainer.
// See server.Call for documentation.
type Conmon_servePortForwardContainer struct {
	*server.Call
}

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

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

// Conmon_List is a list of Conmon.
type Conmon_List = capnp.CapList[Conmon]

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

type Conmon_VersionRequest capnp.Struct

// Conmon_VersionRequest_TypeID is the unique identifier for the type Conmon_VersionRequest.
const Conmon_VersionRequest_TypeID = 0xad2a33d6b9304413

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

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

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

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

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

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

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

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

func (s Conmon_VersionRequest) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_VersionRequest) Verbose() bool {
	return capnp.Struct(s).Bit(0)
}

func (s Conmon_VersionRequest) SetVerbose(v bool) {
	capnp.Struct(s).SetBit(0, v)
}

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

func (s Conmon_VersionRequest) HasMetadataOld() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_VersionRequest) Metadata() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_VersionRequest) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Conmon_VersionRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(1, v.ToPtr())
}

// NewMetadata sets the metadata field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_VersionRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(1, l.ToPtr())
	return l, err
}

// Conmon_VersionRequest_List is a list of Conmon_VersionRequest.
type Conmon_VersionRequest_List = capnp.StructList[Conmon_VersionRequest]

// NewConmon_VersionRequest creates a new list of Conmon_VersionRequest.
func NewConmon_VersionRequest_List(s *capnp.Segment, sz int32) (Conmon_VersionRequest_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
	return capnp.StructList[Conmon_VersionRequest](l), err
}

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

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

type Conmon_VersionResponse capnp.Struct

// Conmon_VersionResponse_TypeID is the unique identifier for the type Conmon_VersionResponse.
const Conmon_VersionResponse_TypeID = 0xf34be5cbac1feed1

func NewConmon_VersionResponse(s *capnp.Segment) (Conmon_VersionResponse, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 9})
	return Conmon_VersionResponse(st), err
}

func NewRootConmon_VersionResponse(s *capnp.Segment) (Conmon_VersionResponse, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 9})
	return Conmon_VersionResponse(st), err
}

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

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

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

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

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

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

func (s Conmon_VersionResponse) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_VersionResponse) ProcessId() uint32 {
	return capnp.Struct(s).Uint32(0)
}

func (s Conmon_VersionResponse) SetProcessId(v uint32) {
	capnp.Struct(s).SetUint32(0, v)
}

func (s Conmon_VersionResponse) Version() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_VersionResponse) HasVersion() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_VersionResponse) SetVersion(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

func (s Conmon_VersionResponse) Tag() (string, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.Text(), err
}

func (s Conmon_VersionResponse) HasTag() bool {
	return capnp.Struct(s).HasPtr(1)
}

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

func (s Conmon_VersionResponse) SetTag(v string) error {
	return capnp.Struct(s).SetText(1, v)
}

func (s Conmon_VersionResponse) Commit() (string, error) {
	p, err := capnp.Struct(s).Ptr(2)
	return p.Text(), err
}

func (s Conmon_VersionResponse) HasCommit() bool {
	return capnp.Struct(s).HasPtr(2)
}

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

func (s Conmon_VersionResponse) SetCommit(v string) error {
	return capnp.Struct(s).SetText(2, v)
}

func (s Conmon_VersionResponse) BuildDate() (string, error) {
	p, err := capnp.Struct(s).Ptr(3)
	return p.Text(), err
}

func (s Conmon_VersionResponse) HasBuildDate() bool {
	return capnp.Struct(s).HasPtr(3)
}

func (s Conmon_VersionResponse) BuildDateBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(3)
	return p.TextBytes(), err
}

func (s Conmon_VersionResponse) SetBuildDate(v string) error {
	return capnp.Struct(s).SetText(3, v)
}

func (s Conmon_VersionResponse) Target() (string, error) {
	p, err := capnp.Struct(s).Ptr(4)
	return p.Text(), err
}

func (s Conmon_VersionResponse) HasTarget() bool {
	return capnp.Struct(s).HasPtr(4)
}

func (s Conmon_VersionResponse) TargetBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(4)
	return p.TextBytes(), err
}

func (s Conmon_VersionResponse) SetTarget(v string) error {
	return capnp.Struct(s).SetText(4, v)
}

func (s Conmon_VersionResponse) RustVersion() (string, error) {
	p, err := capnp.Struct(s).Ptr(5)
	return p.Text(), err
}

func (s Conmon_VersionResponse) HasRustVersion() bool {
	return capnp.Struct(s).HasPtr(5)
}

func (s Conmon_VersionResponse) RustVersionBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(5)
	return p.TextBytes(), err
}

func (s Conmon_VersionResponse) SetRustVersion(v string) error {
	return capnp.Struct(s).SetText(5, v)
}

func (s Conmon_VersionResponse) CargoVersion() (string, error) {
	p, err := capnp.Struct(s).Ptr(6)
	return p.Text(), err
}

func (s Conmon_VersionResponse) HasCargoVersion() bool {
	return capnp.Struct(s).HasPtr(6)
}

func (s Conmon_VersionResponse) CargoVersionBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(6)
	return p.TextBytes(), err
}

func (s Conmon_VersionResponse) SetCargoVersion(v string) error {
	return capnp.Struct(s).SetText(6, v)
}

func (s Conmon_VersionResponse) CargoTree() (string, error) {
	p, err := capnp.Struct(s).Ptr(7)
	return p.Text(), err
}

func (s Conmon_VersionResponse) HasCargoTree() bool {
	return capnp.Struct(s).HasPtr(7)
}

func (s Conmon_VersionResponse) CargoTreeBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(7)
	return p.TextBytes(), err
}

func (s Conmon_VersionResponse) SetCargoTree(v string) error {
	return capnp.Struct(s).SetText(7, v)
}

func (s Conmon_VersionResponse) Metadata() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(8)
	return []byte(p.Data()), err
}

func (s Conmon_VersionResponse) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(8)
}

func (s Conmon_VersionResponse) SetMetadata(v []byte) error {
	return capnp.Struct(s).SetData(8, v)
}

// Conmon_VersionResponse_List is a list of Conmon_VersionResponse.
type Conmon_VersionResponse_List = capnp.StructList[Conmon_VersionResponse]

// NewConmon_VersionResponse creates a new list of Conmon_VersionResponse.
func NewConmon_VersionResponse_List(s *capnp.Segment, sz int32) (Conmon_VersionResponse_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 9}, sz)
	return capnp.StructList[Conmon_VersionResponse](l), err
}

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

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

type Conmon_CreateContainerRequest capnp.Struct

// Conmon_CreateContainerRequest_TypeID is the unique identifier for the type Conmon_CreateContainerRequest.
const Conmon_CreateContainerRequest_TypeID = 0xba77e3fa3aa9b6ca

func NewConmon_CreateContainerRequest(s *capnp.Segment) (Conmon_CreateContainerRequest, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 13})
	return Conmon_CreateContainerRequest(st), err
}

func NewRootConmon_CreateContainerRequest(s *capnp.Segment) (Conmon_CreateContainerRequest, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 13})
	return Conmon_CreateContainerRequest(st), err
}

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

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

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

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

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

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

func (s Conmon_CreateContainerRequest) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_CreateContainerRequest) Id() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_CreateContainerRequest) HasId() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_CreateContainerRequest) SetId(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

func (s Conmon_CreateContainerRequest) BundlePath() (string, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.Text(), err
}

func (s Conmon_CreateContainerRequest) HasBundlePath() bool {
	return capnp.Struct(s).HasPtr(1)
}

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

func (s Conmon_CreateContainerRequest) SetBundlePath(v string) error {
	return capnp.Struct(s).SetText(1, v)
}

func (s Conmon_CreateContainerRequest) Terminal() bool {
	return capnp.Struct(s).Bit(0)
}

func (s Conmon_CreateContainerRequest) SetTerminal(v bool) {
	capnp.Struct(s).SetBit(0, v)
}

func (s Conmon_CreateContainerRequest) Stdin() bool {
	return capnp.Struct(s).Bit(1)
}

func (s Conmon_CreateContainerRequest) SetStdin(v bool) {
	capnp.Struct(s).SetBit(1, v)
}

func (s Conmon_CreateContainerRequest) ExitPaths() (capnp.TextList, error) {
	p, err := capnp.Struct(s).Ptr(2)
	return capnp.TextList(p.List()), err
}

func (s Conmon_CreateContainerRequest) HasExitPaths() bool {
	return capnp.Struct(s).HasPtr(2)
}

func (s Conmon_CreateContainerRequest) SetExitPaths(v capnp.TextList) error {
	return capnp.Struct(s).SetPtr(2, v.ToPtr())
}

// NewExitPaths sets the exitPaths field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s Conmon_CreateContainerRequest) NewExitPaths(n int32) (capnp.TextList, error) {
	l, err := capnp.NewTextList(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.TextList{}, err
	}
	err = capnp.Struct(s).SetPtr(2, l.ToPtr())
	return l, err
}
func (s Conmon_CreateContainerRequest) OomExitPaths() (capnp.TextList, error) {
	p, err := capnp.Struct(s).Ptr(3)
	return capnp.TextList(p.List()), err
}

func (s Conmon_CreateContainerRequest) HasOomExitPaths() bool {
	return capnp.Struct(s).HasPtr(3)
}

func (s Conmon_CreateContainerRequest) SetOomExitPaths(v capnp.TextList) error {
	return capnp.Struct(s).SetPtr(3, v.ToPtr())
}

// NewOomExitPaths sets the oomExitPaths field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s Conmon_CreateContainerRequest) NewOomExitPaths(n int32) (capnp.TextList, error) {
	l, err := capnp.NewTextList(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.TextList{}, err
	}
	err = capnp.Struct(s).SetPtr(3, l.ToPtr())
	return l, err
}
func (s Conmon_CreateContainerRequest) LogDrivers() (Conmon_LogDriver_List, error) {
	p, err := capnp.Struct(s).Ptr(4)
	return Conmon_LogDriver_List(p.List()), err
}

func (s Conmon_CreateContainerRequest) HasLogDrivers() bool {
	return capnp.Struct(s).HasPtr(4)
}

func (s Conmon_CreateContainerRequest) SetLogDrivers(v Conmon_LogDriver_List) error {
	return capnp.Struct(s).SetPtr(4, v.ToPtr())
}

// NewLogDrivers sets the logDrivers field to a newly
// allocated Conmon_LogDriver_List, preferring placement in s's segment.
func (s Conmon_CreateContainerRequest) NewLogDrivers(n int32) (Conmon_LogDriver_List, error) {
	l, err := NewConmon_LogDriver_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_LogDriver_List{}, err
	}
	err = capnp.Struct(s).SetPtr(4, l.ToPtr())
	return l, err
}
func (s Conmon_CreateContainerRequest) CleanupCmd() (capnp.TextList, error) {
	p, err := capnp.Struct(s).Ptr(5)
	return capnp.TextList(p.List()), err
}

func (s Conmon_CreateContainerRequest) HasCleanupCmd() bool {
	return capnp.Struct(s).HasPtr(5)
}

func (s Conmon_CreateContainerRequest) SetCleanupCmd(v capnp.TextList) error {
	return capnp.Struct(s).SetPtr(5, v.ToPtr())
}

// NewCleanupCmd sets the cleanupCmd field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s Conmon_CreateContainerRequest) NewCleanupCmd(n int32) (capnp.TextList, error) {
	l, err := capnp.NewTextList(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.TextList{}, err
	}
	err = capnp.Struct(s).SetPtr(5, l.ToPtr())
	return l, err
}
func (s Conmon_CreateContainerRequest) GlobalArgs() (capnp.TextList, error) {
	p, err := capnp.Struct(s).Ptr(6)
	return capnp.TextList(p.List()), err
}

func (s Conmon_CreateContainerRequest) HasGlobalArgs() bool {
	return capnp.Struct(s).HasPtr(6)
}

func (s Conmon_CreateContainerRequest) SetGlobalArgs(v capnp.TextList) error {
	return capnp.Struct(s).SetPtr(6, v.ToPtr())
}

// NewGlobalArgs sets the globalArgs field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s Conmon_CreateContainerRequest) NewGlobalArgs(n int32) (capnp.TextList, error) {
	l, err := capnp.NewTextList(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.TextList{}, err
	}
	err = capnp.Struct(s).SetPtr(6, l.ToPtr())
	return l, err
}
func (s Conmon_CreateContainerRequest) CommandArgs() (capnp.TextList, error) {
	p, err := capnp.Struct(s).Ptr(7)
	return capnp.TextList(p.List()), err
}

func (s Conmon_CreateContainerRequest) HasCommandArgs() bool {
	return capnp.Struct(s).HasPtr(7)
}

func (s Conmon_CreateContainerRequest) SetCommandArgs(v capnp.TextList) error {
	return capnp.Struct(s).SetPtr(7, v.ToPtr())
}

// NewCommandArgs sets the commandArgs field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s Conmon_CreateContainerRequest) NewCommandArgs(n int32) (capnp.TextList, error) {
	l, err := capnp.NewTextList(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.TextList{}, err
	}
	err = capnp.Struct(s).SetPtr(7, l.ToPtr())
	return l, err
}
func (s Conmon_CreateContainerRequest) MetadataOld() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(8)
	return []byte(p.Data()), err
}

func (s Conmon_CreateContainerRequest) HasMetadataOld() bool {
	return capnp.Struct(s).HasPtr(8)
}

func (s Conmon_CreateContainerRequest) SetMetadataOld(v []byte) error {
	return capnp.Struct(s).SetData(8, v)
}

func (s Conmon_CreateContainerRequest) Metadata() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(9)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_CreateContainerRequest) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(9)
}

func (s Conmon_CreateContainerRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(9, v.ToPtr())
}

// NewMetadata sets the metadata field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_CreateContainerRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(9, l.ToPtr())
	return l, err
}
func (s Conmon_CreateContainerRequest) EnvVars() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(10)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_CreateContainerRequest) HasEnvVars() bool {
	return capnp.Struct(s).HasPtr(10)
}

func (s Conmon_CreateContainerRequest) SetEnvVars(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(10, v.ToPtr())
}

// NewEnvVars sets the envVars field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_CreateContainerRequest) NewEnvVars(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(10, l.ToPtr())
	return l, err
}
func (s Conmon_CreateContainerRequest) CgroupManager() Conmon_CgroupManager {
	return Conmon_CgroupManager(capnp.Struct(s).Uint16(2))
}

func (s Conmon_CreateContainerRequest) SetCgroupManager(v Conmon_CgroupManager) {
	capnp.Struct(s).SetUint16(2, uint16(v))
}

func (s Conmon_CreateContainerRequest) AdditionalFds() (capnp.UInt64List, error) {
	p, err := capnp.Struct(s).Ptr(11)
	return capnp.UInt64List(p.List()), err
}

func (s Conmon_CreateContainerRequest) HasAdditionalFds() bool {
	return capnp.Struct(s).HasPtr(11)
}

func (s Conmon_CreateContainerRequest) SetAdditionalFds(v capnp.UInt64List) error {
	return capnp.Struct(s).SetPtr(11, v.ToPtr())
}

// NewAdditionalFds sets the additionalFds field to a newly
// allocated capnp.UInt64List, preferring placement in s's segment.
func (s Conmon_CreateContainerRequest) NewAdditionalFds(n int32) (capnp.UInt64List, error) {
	l, err := capnp.NewUInt64List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.UInt64List{}, err
	}
	err = capnp.Struct(s).SetPtr(11, l.ToPtr())
	return l, err
}
func (s Conmon_CreateContainerRequest) LeakFds() (capnp.UInt64List, error) {
	p, err := capnp.Struct(s).Ptr(12)
	return capnp.UInt64List(p.List()), err
}

func (s Conmon_CreateContainerRequest) HasLeakFds() bool {
	return capnp.Struct(s).HasPtr(12)
}

func (s Conmon_CreateContainerRequest) SetLeakFds(v capnp.UInt64List) error {
	return capnp.Struct(s).SetPtr(12, v.ToPtr())
}

// NewLeakFds sets the leakFds field to a newly
// allocated capnp.UInt64List, preferring placement in s's segment.
func (s Conmon_CreateContainerRequest) NewLeakFds(n int32) (capnp.UInt64List, error) {
	l, err := capnp.NewUInt64List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.UInt64List{}, err
	}
	err = capnp.Struct(s).SetPtr(12, l.ToPtr())
	return l, err
}

// Conmon_CreateContainerRequest_List is a list of Conmon_CreateContainerRequest.
type Conmon_CreateContainerRequest_List = capnp.StructList[Conmon_CreateContainerRequest]

// NewConmon_CreateContainerRequest creates a new list of Conmon_CreateContainerRequest.
func NewConmon_CreateContainerRequest_List(s *capnp.Segment, sz int32) (Conmon_CreateContainerRequest_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 13}, sz)
	return capnp.StructList[Conmon_CreateContainerRequest](l), err
}

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

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

type Conmon_LogDriver capnp.Struct

// Conmon_LogDriver_TypeID is the unique identifier for the type Conmon_LogDriver.
const Conmon_LogDriver_TypeID = 0xae78ee8eb6b3a134

func NewConmon_LogDriver(s *capnp.Segment) (Conmon_LogDriver, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
	return Conmon_LogDriver(st), err
}

func NewRootConmon_LogDriver(s *capnp.Segment) (Conmon_LogDriver, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
	return Conmon_LogDriver(st), err
}

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

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

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

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

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

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

func (s Conmon_LogDriver) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_LogDriver) Type() Conmon_LogDriver_Type {
	return Conmon_LogDriver_Type(capnp.Struct(s).Uint16(0))
}

func (s Conmon_LogDriver) SetType(v Conmon_LogDriver_Type) {
	capnp.Struct(s).SetUint16(0, uint16(v))
}

func (s Conmon_LogDriver) Path() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_LogDriver) HasPath() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_LogDriver) SetPath(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

func (s Conmon_LogDriver) MaxSize() uint64 {
	return capnp.Struct(s).Uint64(8)
}

func (s Conmon_LogDriver) SetMaxSize(v uint64) {
	capnp.Struct(s).SetUint64(8, v)
}

// Conmon_LogDriver_List is a list of Conmon_LogDriver.
type Conmon_LogDriver_List = capnp.StructList[Conmon_LogDriver]

// NewConmon_LogDriver creates a new list of Conmon_LogDriver.
func NewConmon_LogDriver_List(s *capnp.Segment, sz int32) (Conmon_LogDriver_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}, sz)
	return capnp.StructList[Conmon_LogDriver](l), err
}

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

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

type Conmon_LogDriver_Type uint16

// Conmon_LogDriver_Type_TypeID is the unique identifier for the type Conmon_LogDriver_Type.
const Conmon_LogDriver_Type_TypeID = 0xf026e3d750335bc1

// Values of Conmon_LogDriver_Type.
const (
	Conmon_LogDriver_Type_containerRuntimeInterface Conmon_LogDriver_Type = 0
	Conmon_LogDriver_Type_json                      Conmon_LogDriver_Type = 1
	Conmon_LogDriver_Type_journald                  Conmon_LogDriver_Type = 2
)

// String returns the enum's constant name.
func (c Conmon_LogDriver_Type) String() string {
	switch c {
	case Conmon_LogDriver_Type_containerRuntimeInterface:
		return "containerRuntimeInterface"
	case Conmon_LogDriver_Type_json:
		return "json"
	case Conmon_LogDriver_Type_journald:
		return "journald"

	default:
		return ""
	}
}

// Conmon_LogDriver_TypeFromString returns the enum value with a name,
// or the zero value if there's no such value.
func Conmon_LogDriver_TypeFromString(c string) Conmon_LogDriver_Type {
	switch c {
	case "containerRuntimeInterface":
		return Conmon_LogDriver_Type_containerRuntimeInterface
	case "json":
		return Conmon_LogDriver_Type_json
	case "journald":
		return Conmon_LogDriver_Type_journald

	default:
		return 0
	}
}

type Conmon_LogDriver_Type_List = capnp.EnumList[Conmon_LogDriver_Type]

func NewConmon_LogDriver_Type_List(s *capnp.Segment, sz int32) (Conmon_LogDriver_Type_List, error) {
	return capnp.NewEnumList[Conmon_LogDriver_Type](s, sz)
}

type Conmon_CgroupManager uint16

// Conmon_CgroupManager_TypeID is the unique identifier for the type Conmon_CgroupManager.
const Conmon_CgroupManager_TypeID = 0xaa4bbac12765a78a

// Values of Conmon_CgroupManager.
const (
	Conmon_CgroupManager_systemd  Conmon_CgroupManager = 0
	Conmon_CgroupManager_cgroupfs Conmon_CgroupManager = 1
)

// String returns the enum's constant name.
func (c Conmon_CgroupManager) String() string {
	switch c {
	case Conmon_CgroupManager_systemd:
		return "systemd"
	case Conmon_CgroupManager_cgroupfs:
		return "cgroupfs"

	default:
		return ""
	}
}

// Conmon_CgroupManagerFromString returns the enum value with a name,
// or the zero value if there's no such value.
func Conmon_CgroupManagerFromString(c string) Conmon_CgroupManager {
	switch c {
	case "systemd":
		return Conmon_CgroupManager_systemd
	case "cgroupfs":
		return Conmon_CgroupManager_cgroupfs

	default:
		return 0
	}
}

type Conmon_CgroupManager_List = capnp.EnumList[Conmon_CgroupManager]

func NewConmon_CgroupManager_List(s *capnp.Segment, sz int32) (Conmon_CgroupManager_List, error) {
	return capnp.NewEnumList[Conmon_CgroupManager](s, sz)
}

type Conmon_CreateContainerResponse capnp.Struct

// Conmon_CreateContainerResponse_TypeID is the unique identifier for the type Conmon_CreateContainerResponse.
const Conmon_CreateContainerResponse_TypeID = 0xde3a625e70772b9a

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

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

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

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

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

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

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

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

func (s Conmon_CreateContainerResponse) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_CreateContainerResponse) ContainerPid() uint32 {
	return capnp.Struct(s).Uint32(0)
}

func (s Conmon_CreateContainerResponse) SetContainerPid(v uint32) {
	capnp.Struct(s).SetUint32(0, v)
}

// Conmon_CreateContainerResponse_List is a list of Conmon_CreateContainerResponse.
type Conmon_CreateContainerResponse_List = capnp.StructList[Conmon_CreateContainerResponse]

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

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

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

type Conmon_ExecSyncContainerRequest capnp.Struct

// Conmon_ExecSyncContainerRequest_TypeID is the unique identifier for the type Conmon_ExecSyncContainerRequest.
const Conmon_ExecSyncContainerRequest_TypeID = 0xf41122f890a371a6

func NewConmon_ExecSyncContainerRequest(s *capnp.Segment) (Conmon_ExecSyncContainerRequest, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 5})
	return Conmon_ExecSyncContainerRequest(st), err
}

func NewRootConmon_ExecSyncContainerRequest(s *capnp.Segment) (Conmon_ExecSyncContainerRequest, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 5})
	return Conmon_ExecSyncContainerRequest(st), err
}

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

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

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

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

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

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

func (s Conmon_ExecSyncContainerRequest) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_ExecSyncContainerRequest) Id() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_ExecSyncContainerRequest) HasId() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_ExecSyncContainerRequest) SetId(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

func (s Conmon_ExecSyncContainerRequest) TimeoutSec() uint64 {
	return capnp.Struct(s).Uint64(0)
}

func (s Conmon_ExecSyncContainerRequest) SetTimeoutSec(v uint64) {
	capnp.Struct(s).SetUint64(0, v)
}

func (s Conmon_ExecSyncContainerRequest) Command() (capnp.TextList, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return capnp.TextList(p.List()), err
}

func (s Conmon_ExecSyncContainerRequest) HasCommand() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Conmon_ExecSyncContainerRequest) SetCommand(v capnp.TextList) error {
	return capnp.Struct(s).SetPtr(1, v.ToPtr())
}

// NewCommand sets the command field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s Conmon_ExecSyncContainerRequest) NewCommand(n int32) (capnp.TextList, error) {
	l, err := capnp.NewTextList(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.TextList{}, err
	}
	err = capnp.Struct(s).SetPtr(1, l.ToPtr())
	return l, err
}
func (s Conmon_ExecSyncContainerRequest) Terminal() bool {
	return capnp.Struct(s).Bit(64)
}

func (s Conmon_ExecSyncContainerRequest) SetTerminal(v bool) {
	capnp.Struct(s).SetBit(64, v)
}

func (s Conmon_ExecSyncContainerRequest) MetadataOld() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(2)
	return []byte(p.Data()), err
}

func (s Conmon_ExecSyncContainerRequest) HasMetadataOld() bool {
	return capnp.Struct(s).HasPtr(2)
}

func (s Conmon_ExecSyncContainerRequest) SetMetadataOld(v []byte) error {
	return capnp.Struct(s).SetData(2, v)
}

func (s Conmon_ExecSyncContainerRequest) Metadata() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(3)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_ExecSyncContainerRequest) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(3)
}

func (s Conmon_ExecSyncContainerRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(3, v.ToPtr())
}

// NewMetadata sets the metadata field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_ExecSyncContainerRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(3, l.ToPtr())
	return l, err
}
func (s Conmon_ExecSyncContainerRequest) EnvVars() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(4)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_ExecSyncContainerRequest) HasEnvVars() bool {
	return capnp.Struct(s).HasPtr(4)
}

func (s Conmon_ExecSyncContainerRequest) SetEnvVars(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(4, v.ToPtr())
}

// NewEnvVars sets the envVars field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_ExecSyncContainerRequest) NewEnvVars(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(4, l.ToPtr())
	return l, err
}
func (s Conmon_ExecSyncContainerRequest) CgroupManager() Conmon_CgroupManager {
	return Conmon_CgroupManager(capnp.Struct(s).Uint16(10))
}

func (s Conmon_ExecSyncContainerRequest) SetCgroupManager(v Conmon_CgroupManager) {
	capnp.Struct(s).SetUint16(10, uint16(v))
}

// Conmon_ExecSyncContainerRequest_List is a list of Conmon_ExecSyncContainerRequest.
type Conmon_ExecSyncContainerRequest_List = capnp.StructList[Conmon_ExecSyncContainerRequest]

// NewConmon_ExecSyncContainerRequest creates a new list of Conmon_ExecSyncContainerRequest.
func NewConmon_ExecSyncContainerRequest_List(s *capnp.Segment, sz int32) (Conmon_ExecSyncContainerRequest_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 5}, sz)
	return capnp.StructList[Conmon_ExecSyncContainerRequest](l), err
}

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

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

type Conmon_ExecSyncContainerResponse capnp.Struct

// Conmon_ExecSyncContainerResponse_TypeID is the unique identifier for the type Conmon_ExecSyncContainerResponse.
const Conmon_ExecSyncContainerResponse_TypeID = 0xd9d61d1d803c85fc

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

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

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

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

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

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

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

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

func (s Conmon_ExecSyncContainerResponse) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_ExecSyncContainerResponse) ExitCode() int32 {
	return int32(capnp.Struct(s).Uint32(0))
}

func (s Conmon_ExecSyncContainerResponse) SetExitCode(v int32) {
	capnp.Struct(s).SetUint32(0, uint32(v))
}

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

func (s Conmon_ExecSyncContainerResponse) HasStdout() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_ExecSyncContainerResponse) Stderr() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return []byte(p.Data()), err
}

func (s Conmon_ExecSyncContainerResponse) HasStderr() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Conmon_ExecSyncContainerResponse) SetStderr(v []byte) error {
	return capnp.Struct(s).SetData(1, v)
}

func (s Conmon_ExecSyncContainerResponse) TimedOut() bool {
	return capnp.Struct(s).Bit(32)
}

func (s Conmon_ExecSyncContainerResponse) SetTimedOut(v bool) {
	capnp.Struct(s).SetBit(32, v)
}

// Conmon_ExecSyncContainerResponse_List is a list of Conmon_ExecSyncContainerResponse.
type Conmon_ExecSyncContainerResponse_List = capnp.StructList[Conmon_ExecSyncContainerResponse]

// NewConmon_ExecSyncContainerResponse creates a new list of Conmon_ExecSyncContainerResponse.
func NewConmon_ExecSyncContainerResponse_List(s *capnp.Segment, sz int32) (Conmon_ExecSyncContainerResponse_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
	return capnp.StructList[Conmon_ExecSyncContainerResponse](l), err
}

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

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

type Conmon_AttachRequest capnp.Struct

// Conmon_AttachRequest_TypeID is the unique identifier for the type Conmon_AttachRequest.
const Conmon_AttachRequest_TypeID = 0xdf703ca0befc3afc

func NewConmon_AttachRequest(s *capnp.Segment) (Conmon_AttachRequest, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5})
	return Conmon_AttachRequest(st), err
}

func NewRootConmon_AttachRequest(s *capnp.Segment) (Conmon_AttachRequest, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5})
	return Conmon_AttachRequest(st), err
}

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

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

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

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

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

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

func (s Conmon_AttachRequest) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_AttachRequest) Id() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_AttachRequest) HasId() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_AttachRequest) SetId(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

func (s Conmon_AttachRequest) SocketPath() (string, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.Text(), err
}

func (s Conmon_AttachRequest) HasSocketPath() bool {
	return capnp.Struct(s).HasPtr(1)
}

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

func (s Conmon_AttachRequest) SetSocketPath(v string) error {
	return capnp.Struct(s).SetText(1, v)
}

func (s Conmon_AttachRequest) ExecSessionId() (string, error) {
	p, err := capnp.Struct(s).Ptr(2)
	return p.Text(), err
}

func (s Conmon_AttachRequest) HasExecSessionId() bool {
	return capnp.Struct(s).HasPtr(2)
}

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

func (s Conmon_AttachRequest) SetExecSessionId(v string) error {
	return capnp.Struct(s).SetText(2, v)
}

func (s Conmon_AttachRequest) StopAfterStdinEof() bool {
	return capnp.Struct(s).Bit(0)
}

func (s Conmon_AttachRequest) SetStopAfterStdinEof(v bool) {
	capnp.Struct(s).SetBit(0, v)
}

func (s Conmon_AttachRequest) MetadataOld() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(3)
	return []byte(p.Data()), err
}

func (s Conmon_AttachRequest) HasMetadataOld() bool {
	return capnp.Struct(s).HasPtr(3)
}

func (s Conmon_AttachRequest) SetMetadataOld(v []byte) error {
	return capnp.Struct(s).SetData(3, v)
}

func (s Conmon_AttachRequest) Metadata() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(4)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_AttachRequest) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(4)
}

func (s Conmon_AttachRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(4, v.ToPtr())
}

// NewMetadata sets the metadata field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_AttachRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(4, l.ToPtr())
	return l, err
}

// Conmon_AttachRequest_List is a list of Conmon_AttachRequest.
type Conmon_AttachRequest_List = capnp.StructList[Conmon_AttachRequest]

// NewConmon_AttachRequest creates a new list of Conmon_AttachRequest.
func NewConmon_AttachRequest_List(s *capnp.Segment, sz int32) (Conmon_AttachRequest_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5}, sz)
	return capnp.StructList[Conmon_AttachRequest](l), err
}

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

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

type Conmon_AttachResponse capnp.Struct

// Conmon_AttachResponse_TypeID is the unique identifier for the type Conmon_AttachResponse.
const Conmon_AttachResponse_TypeID = 0xace5517aafc86077

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

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

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

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

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

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

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

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

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

// Conmon_AttachResponse_List is a list of Conmon_AttachResponse.
type Conmon_AttachResponse_List = capnp.StructList[Conmon_AttachResponse]

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

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

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

type Conmon_ReopenLogRequest capnp.Struct

// Conmon_ReopenLogRequest_TypeID is the unique identifier for the type Conmon_ReopenLogRequest.
const Conmon_ReopenLogRequest_TypeID = 0xd0476e0f34d1411a

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

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

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

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

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

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

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

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

func (s Conmon_ReopenLogRequest) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_ReopenLogRequest) Id() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_ReopenLogRequest) HasId() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_ReopenLogRequest) SetId(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

func (s Conmon_ReopenLogRequest) MetadataOld() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return []byte(p.Data()), err
}

func (s Conmon_ReopenLogRequest) HasMetadataOld() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Conmon_ReopenLogRequest) SetMetadataOld(v []byte) error {
	return capnp.Struct(s).SetData(1, v)
}

func (s Conmon_ReopenLogRequest) Metadata() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(2)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_ReopenLogRequest) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(2)
}

func (s Conmon_ReopenLogRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(2, v.ToPtr())
}

// NewMetadata sets the metadata field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_ReopenLogRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(2, l.ToPtr())
	return l, err
}

// Conmon_ReopenLogRequest_List is a list of Conmon_ReopenLogRequest.
type Conmon_ReopenLogRequest_List = capnp.StructList[Conmon_ReopenLogRequest]

// NewConmon_ReopenLogRequest creates a new list of Conmon_ReopenLogRequest.
func NewConmon_ReopenLogRequest_List(s *capnp.Segment, sz int32) (Conmon_ReopenLogRequest_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
	return capnp.StructList[Conmon_ReopenLogRequest](l), err
}

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

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

type Conmon_ReopenLogResponse capnp.Struct

// Conmon_ReopenLogResponse_TypeID is the unique identifier for the type Conmon_ReopenLogResponse.
const Conmon_ReopenLogResponse_TypeID = 0xa20f49456be85b99

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

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

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

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

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

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

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

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

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

// Conmon_ReopenLogResponse_List is a list of Conmon_ReopenLogResponse.
type Conmon_ReopenLogResponse_List = capnp.StructList[Conmon_ReopenLogResponse]

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

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

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

type Conmon_SetWindowSizeRequest capnp.Struct

// Conmon_SetWindowSizeRequest_TypeID is the unique identifier for the type Conmon_SetWindowSizeRequest.
const Conmon_SetWindowSizeRequest_TypeID = 0xb5418b8ea8ead17b

func NewConmon_SetWindowSizeRequest(s *capnp.Segment) (Conmon_SetWindowSizeRequest, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
	return Conmon_SetWindowSizeRequest(st), err
}

func NewRootConmon_SetWindowSizeRequest(s *capnp.Segment) (Conmon_SetWindowSizeRequest, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
	return Conmon_SetWindowSizeRequest(st), err
}

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

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

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

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

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

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

func (s Conmon_SetWindowSizeRequest) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_SetWindowSizeRequest) Id() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_SetWindowSizeRequest) HasId() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_SetWindowSizeRequest) SetId(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

func (s Conmon_SetWindowSizeRequest) Width() uint16 {
	return capnp.Struct(s).Uint16(0)
}

func (s Conmon_SetWindowSizeRequest) SetWidth(v uint16) {
	capnp.Struct(s).SetUint16(0, v)
}

func (s Conmon_SetWindowSizeRequest) Height() uint16 {
	return capnp.Struct(s).Uint16(2)
}

func (s Conmon_SetWindowSizeRequest) SetHeight(v uint16) {
	capnp.Struct(s).SetUint16(2, v)
}

func (s Conmon_SetWindowSizeRequest) MetadataOld() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return []byte(p.Data()), err
}

func (s Conmon_SetWindowSizeRequest) HasMetadataOld() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Conmon_SetWindowSizeRequest) SetMetadataOld(v []byte) error {
	return capnp.Struct(s).SetData(1, v)
}

func (s Conmon_SetWindowSizeRequest) Metadata() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(2)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_SetWindowSizeRequest) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(2)
}

func (s Conmon_SetWindowSizeRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(2, v.ToPtr())
}

// NewMetadata sets the metadata field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_SetWindowSizeRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(2, l.ToPtr())
	return l, err
}

// Conmon_SetWindowSizeRequest_List is a list of Conmon_SetWindowSizeRequest.
type Conmon_SetWindowSizeRequest_List = capnp.StructList[Conmon_SetWindowSizeRequest]

// NewConmon_SetWindowSizeRequest creates a new list of Conmon_SetWindowSizeRequest.
func NewConmon_SetWindowSizeRequest_List(s *capnp.Segment, sz int32) (Conmon_SetWindowSizeRequest_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}, sz)
	return capnp.StructList[Conmon_SetWindowSizeRequest](l), err
}

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

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

type Conmon_SetWindowSizeResponse capnp.Struct

// Conmon_SetWindowSizeResponse_TypeID is the unique identifier for the type Conmon_SetWindowSizeResponse.
const Conmon_SetWindowSizeResponse_TypeID = 0xf9b3cd8033aba1f8

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

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

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

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

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

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

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

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

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

// Conmon_SetWindowSizeResponse_List is a list of Conmon_SetWindowSizeResponse.
type Conmon_SetWindowSizeResponse_List = capnp.StructList[Conmon_SetWindowSizeResponse]

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

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

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

type Conmon_CreateNamespacesRequest capnp.Struct

// Conmon_CreateNamespacesRequest_TypeID is the unique identifier for the type Conmon_CreateNamespacesRequest.
const Conmon_CreateNamespacesRequest_TypeID = 0x8b5b1693940f607e

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

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

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

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

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

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

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

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

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

func (s Conmon_CreateNamespacesRequest) HasMetadataOld() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_CreateNamespacesRequest) Namespaces() (Conmon_Namespace_List, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return Conmon_Namespace_List(p.List()), err
}

func (s Conmon_CreateNamespacesRequest) HasNamespaces() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Conmon_CreateNamespacesRequest) SetNamespaces(v Conmon_Namespace_List) error {
	return capnp.Struct(s).SetPtr(1, v.ToPtr())
}

// NewNamespaces sets the namespaces field to a newly
// allocated Conmon_Namespace_List, preferring placement in s's segment.
func (s Conmon_CreateNamespacesRequest) NewNamespaces(n int32) (Conmon_Namespace_List, error) {
	l, err := NewConmon_Namespace_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_Namespace_List{}, err
	}
	err = capnp.Struct(s).SetPtr(1, l.ToPtr())
	return l, err
}
func (s Conmon_CreateNamespacesRequest) UidMappings() (capnp.TextList, error) {
	p, err := capnp.Struct(s).Ptr(2)
	return capnp.TextList(p.List()), err
}

func (s Conmon_CreateNamespacesRequest) HasUidMappings() bool {
	return capnp.Struct(s).HasPtr(2)
}

func (s Conmon_CreateNamespacesRequest) SetUidMappings(v capnp.TextList) error {
	return capnp.Struct(s).SetPtr(2, v.ToPtr())
}

// NewUidMappings sets the uidMappings field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s Conmon_CreateNamespacesRequest) NewUidMappings(n int32) (capnp.TextList, error) {
	l, err := capnp.NewTextList(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.TextList{}, err
	}
	err = capnp.Struct(s).SetPtr(2, l.ToPtr())
	return l, err
}
func (s Conmon_CreateNamespacesRequest) GidMappings() (capnp.TextList, error) {
	p, err := capnp.Struct(s).Ptr(3)
	return capnp.TextList(p.List()), err
}

func (s Conmon_CreateNamespacesRequest) HasGidMappings() bool {
	return capnp.Struct(s).HasPtr(3)
}

func (s Conmon_CreateNamespacesRequest) SetGidMappings(v capnp.TextList) error {
	return capnp.Struct(s).SetPtr(3, v.ToPtr())
}

// NewGidMappings sets the gidMappings field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s Conmon_CreateNamespacesRequest) NewGidMappings(n int32) (capnp.TextList, error) {
	l, err := capnp.NewTextList(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.TextList{}, err
	}
	err = capnp.Struct(s).SetPtr(3, l.ToPtr())
	return l, err
}
func (s Conmon_CreateNamespacesRequest) BasePath() (string, error) {
	p, err := capnp.Struct(s).Ptr(4)
	return p.Text(), err
}

func (s Conmon_CreateNamespacesRequest) HasBasePath() bool {
	return capnp.Struct(s).HasPtr(4)
}

func (s Conmon_CreateNamespacesRequest) BasePathBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(4)
	return p.TextBytes(), err
}

func (s Conmon_CreateNamespacesRequest) SetBasePath(v string) error {
	return capnp.Struct(s).SetText(4, v)
}

func (s Conmon_CreateNamespacesRequest) PodId() (string, error) {
	p, err := capnp.Struct(s).Ptr(5)
	return p.Text(), err
}

func (s Conmon_CreateNamespacesRequest) HasPodId() bool {
	return capnp.Struct(s).HasPtr(5)
}

func (s Conmon_CreateNamespacesRequest) PodIdBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(5)
	return p.TextBytes(), err
}

func (s Conmon_CreateNamespacesRequest) SetPodId(v string) error {
	return capnp.Struct(s).SetText(5, v)
}

func (s Conmon_CreateNamespacesRequest) Metadata() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(6)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_CreateNamespacesRequest) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(6)
}

func (s Conmon_CreateNamespacesRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(6, v.ToPtr())
}

// NewMetadata sets the metadata field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_CreateNamespacesRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(6, l.ToPtr())
	return l, err
}

// Conmon_CreateNamespacesRequest_List is a list of Conmon_CreateNamespacesRequest.
type Conmon_CreateNamespacesRequest_List = capnp.StructList[Conmon_CreateNamespacesRequest]

// NewConmon_CreateNamespacesRequest creates a new list of Conmon_CreateNamespacesRequest.
func NewConmon_CreateNamespacesRequest_List(s *capnp.Segment, sz int32) (Conmon_CreateNamespacesRequest_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 7}, sz)
	return capnp.StructList[Conmon_CreateNamespacesRequest](l), err
}

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

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

type Conmon_Namespace uint16

// Conmon_Namespace_TypeID is the unique identifier for the type Conmon_Namespace.
const Conmon_Namespace_TypeID = 0xd61491b560a8f3a3

// Values of Conmon_Namespace.
const (
	Conmon_Namespace_ipc  Conmon_Namespace = 0
	Conmon_Namespace_net  Conmon_Namespace = 1
	Conmon_Namespace_pid  Conmon_Namespace = 2
	Conmon_Namespace_user Conmon_Namespace = 3
	Conmon_Namespace_uts  Conmon_Namespace = 4
)

// String returns the enum's constant name.
func (c Conmon_Namespace) String() string {
	switch c {
	case Conmon_Namespace_ipc:
		return "ipc"
	case Conmon_Namespace_net:
		return "net"
	case Conmon_Namespace_pid:
		return "pid"
	case Conmon_Namespace_user:
		return "user"
	case Conmon_Namespace_uts:
		return "uts"

	default:
		return ""
	}
}

// Conmon_NamespaceFromString returns the enum value with a name,
// or the zero value if there's no such value.
func Conmon_NamespaceFromString(c string) Conmon_Namespace {
	switch c {
	case "ipc":
		return Conmon_Namespace_ipc
	case "net":
		return Conmon_Namespace_net
	case "pid":
		return Conmon_Namespace_pid
	case "user":
		return Conmon_Namespace_user
	case "uts":
		return Conmon_Namespace_uts

	default:
		return 0
	}
}

type Conmon_Namespace_List = capnp.EnumList[Conmon_Namespace]

func NewConmon_Namespace_List(s *capnp.Segment, sz int32) (Conmon_Namespace_List, error) {
	return capnp.NewEnumList[Conmon_Namespace](s, sz)
}

type Conmon_CreateNamespacesResponse capnp.Struct

// Conmon_CreateNamespacesResponse_TypeID is the unique identifier for the type Conmon_CreateNamespacesResponse.
const Conmon_CreateNamespacesResponse_TypeID = 0x9887a60f577a1ecb

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

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

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

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

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

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

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

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

func (s Conmon_CreateNamespacesResponse) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_CreateNamespacesResponse) Namespaces() (Conmon_NamespaceResponse_List, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_NamespaceResponse_List(p.List()), err
}

func (s Conmon_CreateNamespacesResponse) HasNamespaces() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_CreateNamespacesResponse) SetNamespaces(v Conmon_NamespaceResponse_List) error {
	return capnp.Struct(s).SetPtr(0, v.ToPtr())
}

// NewNamespaces sets the namespaces field to a newly
// allocated Conmon_NamespaceResponse_List, preferring placement in s's segment.
func (s Conmon_CreateNamespacesResponse) NewNamespaces(n int32) (Conmon_NamespaceResponse_List, error) {
	l, err := NewConmon_NamespaceResponse_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_NamespaceResponse_List{}, err
	}
	err = capnp.Struct(s).SetPtr(0, l.ToPtr())
	return l, err
}

// Conmon_CreateNamespacesResponse_List is a list of Conmon_CreateNamespacesResponse.
type Conmon_CreateNamespacesResponse_List = capnp.StructList[Conmon_CreateNamespacesResponse]

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

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

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

type Conmon_NamespaceResponse capnp.Struct

// Conmon_NamespaceResponse_TypeID is the unique identifier for the type Conmon_NamespaceResponse.
const Conmon_NamespaceResponse_TypeID = 0xa93853d6a4e3fa16

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

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

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

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

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

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

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

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

func (s Conmon_NamespaceResponse) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_NamespaceResponse) Type() Conmon_Namespace {
	return Conmon_Namespace(capnp.Struct(s).Uint16(0))
}

func (s Conmon_NamespaceResponse) SetType(v Conmon_Namespace) {
	capnp.Struct(s).SetUint16(0, uint16(v))
}

func (s Conmon_NamespaceResponse) Path() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_NamespaceResponse) HasPath() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_NamespaceResponse) SetPath(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

// Conmon_NamespaceResponse_List is a list of Conmon_NamespaceResponse.
type Conmon_NamespaceResponse_List = capnp.StructList[Conmon_NamespaceResponse]

// NewConmon_NamespaceResponse creates a new list of Conmon_NamespaceResponse.
func NewConmon_NamespaceResponse_List(s *capnp.Segment, sz int32) (Conmon_NamespaceResponse_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
	return capnp.StructList[Conmon_NamespaceResponse](l), err
}

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

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

type Conmon_StartFdSocketRequest capnp.Struct

// Conmon_StartFdSocketRequest_TypeID is the unique identifier for the type Conmon_StartFdSocketRequest.
const Conmon_StartFdSocketRequest_TypeID = 0xba53ab87a688ec29

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

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

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

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

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

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

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

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

func (s Conmon_StartFdSocketRequest) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_StartFdSocketRequest) Metadata() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_StartFdSocketRequest) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_StartFdSocketRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(0, v.ToPtr())
}

// NewMetadata sets the metadata field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_StartFdSocketRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(0, l.ToPtr())
	return l, err
}

// Conmon_StartFdSocketRequest_List is a list of Conmon_StartFdSocketRequest.
type Conmon_StartFdSocketRequest_List = capnp.StructList[Conmon_StartFdSocketRequest]

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

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

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

type Conmon_StartFdSocketResponse capnp.Struct

// Conmon_StartFdSocketResponse_TypeID is the unique identifier for the type Conmon_StartFdSocketResponse.
const Conmon_StartFdSocketResponse_TypeID = 0xb62f418e0ae4e003

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

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

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

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

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

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

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

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

func (s Conmon_StartFdSocketResponse) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_StartFdSocketResponse) Path() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_StartFdSocketResponse) HasPath() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_StartFdSocketResponse) SetPath(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

// Conmon_StartFdSocketResponse_List is a list of Conmon_StartFdSocketResponse.
type Conmon_StartFdSocketResponse_List = capnp.StructList[Conmon_StartFdSocketResponse]

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

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

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

type Conmon_TextTextMapEntry capnp.Struct

// Conmon_TextTextMapEntry_TypeID is the unique identifier for the type Conmon_TextTextMapEntry.
const Conmon_TextTextMapEntry_TypeID = 0xfabbfdde6d4ad392

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

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

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

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

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

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

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

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

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

func (s Conmon_TextTextMapEntry) HasKey() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

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

func (s Conmon_TextTextMapEntry) Value() (string, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.Text(), err
}

func (s Conmon_TextTextMapEntry) HasValue() bool {
	return capnp.Struct(s).HasPtr(1)
}

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

func (s Conmon_TextTextMapEntry) SetValue(v string) error {
	return capnp.Struct(s).SetText(1, v)
}

// Conmon_TextTextMapEntry_List is a list of Conmon_TextTextMapEntry.
type Conmon_TextTextMapEntry_List = capnp.StructList[Conmon_TextTextMapEntry]

// NewConmon_TextTextMapEntry creates a new list of Conmon_TextTextMapEntry.
func NewConmon_TextTextMapEntry_List(s *capnp.Segment, sz int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
	return capnp.StructList[Conmon_TextTextMapEntry](l), err
}

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

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

type Conmon_ServeExecContainerRequest capnp.Struct

// Conmon_ServeExecContainerRequest_TypeID is the unique identifier for the type Conmon_ServeExecContainerRequest.
const Conmon_ServeExecContainerRequest_TypeID = 0xd01c697281e61c21

func NewConmon_ServeExecContainerRequest(s *capnp.Segment) (Conmon_ServeExecContainerRequest, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
	return Conmon_ServeExecContainerRequest(st), err
}

func NewRootConmon_ServeExecContainerRequest(s *capnp.Segment) (Conmon_ServeExecContainerRequest, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
	return Conmon_ServeExecContainerRequest(st), err
}

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

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

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

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

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

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

func (s Conmon_ServeExecContainerRequest) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_ServeExecContainerRequest) Metadata() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_ServeExecContainerRequest) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_ServeExecContainerRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(0, v.ToPtr())
}

// NewMetadata sets the metadata field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_ServeExecContainerRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(0, l.ToPtr())
	return l, err
}
func (s Conmon_ServeExecContainerRequest) Id() (string, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.Text(), err
}

func (s Conmon_ServeExecContainerRequest) HasId() bool {
	return capnp.Struct(s).HasPtr(1)
}

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

func (s Conmon_ServeExecContainerRequest) SetId(v string) error {
	return capnp.Struct(s).SetText(1, v)
}

func (s Conmon_ServeExecContainerRequest) Command() (capnp.TextList, error) {
	p, err := capnp.Struct(s).Ptr(2)
	return capnp.TextList(p.List()), err
}

func (s Conmon_ServeExecContainerRequest) HasCommand() bool {
	return capnp.Struct(s).HasPtr(2)
}

func (s Conmon_ServeExecContainerRequest) SetCommand(v capnp.TextList) error {
	return capnp.Struct(s).SetPtr(2, v.ToPtr())
}

// NewCommand sets the command field to a newly
// allocated capnp.TextList, preferring placement in s's segment.
func (s Conmon_ServeExecContainerRequest) NewCommand(n int32) (capnp.TextList, error) {
	l, err := capnp.NewTextList(capnp.Struct(s).Segment(), n)
	if err != nil {
		return capnp.TextList{}, err
	}
	err = capnp.Struct(s).SetPtr(2, l.ToPtr())
	return l, err
}
func (s Conmon_ServeExecContainerRequest) Tty() bool {
	return capnp.Struct(s).Bit(0)
}

func (s Conmon_ServeExecContainerRequest) SetTty(v bool) {
	capnp.Struct(s).SetBit(0, v)
}

func (s Conmon_ServeExecContainerRequest) Stdin() bool {
	return capnp.Struct(s).Bit(1)
}

func (s Conmon_ServeExecContainerRequest) SetStdin(v bool) {
	capnp.Struct(s).SetBit(1, v)
}

func (s Conmon_ServeExecContainerRequest) Stdout() bool {
	return capnp.Struct(s).Bit(2)
}

func (s Conmon_ServeExecContainerRequest) SetStdout(v bool) {
	capnp.Struct(s).SetBit(2, v)
}

func (s Conmon_ServeExecContainerRequest) Stderr() bool {
	return capnp.Struct(s).Bit(3)
}

func (s Conmon_ServeExecContainerRequest) SetStderr(v bool) {
	capnp.Struct(s).SetBit(3, v)
}

func (s Conmon_ServeExecContainerRequest) CgroupManager() Conmon_CgroupManager {
	return Conmon_CgroupManager(capnp.Struct(s).Uint16(2))
}

func (s Conmon_ServeExecContainerRequest) SetCgroupManager(v Conmon_CgroupManager) {
	capnp.Struct(s).SetUint16(2, uint16(v))
}

// Conmon_ServeExecContainerRequest_List is a list of Conmon_ServeExecContainerRequest.
type Conmon_ServeExecContainerRequest_List = capnp.StructList[Conmon_ServeExecContainerRequest]

// NewConmon_ServeExecContainerRequest creates a new list of Conmon_ServeExecContainerRequest.
func NewConmon_ServeExecContainerRequest_List(s *capnp.Segment, sz int32) (Conmon_ServeExecContainerRequest_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}, sz)
	return capnp.StructList[Conmon_ServeExecContainerRequest](l), err
}

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

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

type Conmon_ServeExecContainerResponse capnp.Struct

// Conmon_ServeExecContainerResponse_TypeID is the unique identifier for the type Conmon_ServeExecContainerResponse.
const Conmon_ServeExecContainerResponse_TypeID = 0xa9e93cf268b17735

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

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

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

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

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

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

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

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

func (s Conmon_ServeExecContainerResponse) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_ServeExecContainerResponse) Url() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_ServeExecContainerResponse) HasUrl() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_ServeExecContainerResponse) SetUrl(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

// Conmon_ServeExecContainerResponse_List is a list of Conmon_ServeExecContainerResponse.
type Conmon_ServeExecContainerResponse_List = capnp.StructList[Conmon_ServeExecContainerResponse]

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

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

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

type Conmon_ServeAttachContainerRequest capnp.Struct

// Conmon_ServeAttachContainerRequest_TypeID is the unique identifier for the type Conmon_ServeAttachContainerRequest.
const Conmon_ServeAttachContainerRequest_TypeID = 0xca8c8e0d7826ae86

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

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

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

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

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

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

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

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

func (s Conmon_ServeAttachContainerRequest) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_ServeAttachContainerRequest) Metadata() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_ServeAttachContainerRequest) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_ServeAttachContainerRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(0, v.ToPtr())
}

// NewMetadata sets the metadata field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_ServeAttachContainerRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(0, l.ToPtr())
	return l, err
}
func (s Conmon_ServeAttachContainerRequest) Id() (string, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.Text(), err
}

func (s Conmon_ServeAttachContainerRequest) HasId() bool {
	return capnp.Struct(s).HasPtr(1)
}

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

func (s Conmon_ServeAttachContainerRequest) SetId(v string) error {
	return capnp.Struct(s).SetText(1, v)
}

func (s Conmon_ServeAttachContainerRequest) Stdin() bool {
	return capnp.Struct(s).Bit(0)
}

func (s Conmon_ServeAttachContainerRequest) SetStdin(v bool) {
	capnp.Struct(s).SetBit(0, v)
}

func (s Conmon_ServeAttachContainerRequest) Stdout() bool {
	return capnp.Struct(s).Bit(1)
}

func (s Conmon_ServeAttachContainerRequest) SetStdout(v bool) {
	capnp.Struct(s).SetBit(1, v)
}

func (s Conmon_ServeAttachContainerRequest) Stderr() bool {
	return capnp.Struct(s).Bit(2)
}

func (s Conmon_ServeAttachContainerRequest) SetStderr(v bool) {
	capnp.Struct(s).SetBit(2, v)
}

// Conmon_ServeAttachContainerRequest_List is a list of Conmon_ServeAttachContainerRequest.
type Conmon_ServeAttachContainerRequest_List = capnp.StructList[Conmon_ServeAttachContainerRequest]

// NewConmon_ServeAttachContainerRequest creates a new list of Conmon_ServeAttachContainerRequest.
func NewConmon_ServeAttachContainerRequest_List(s *capnp.Segment, sz int32) (Conmon_ServeAttachContainerRequest_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
	return capnp.StructList[Conmon_ServeAttachContainerRequest](l), err
}

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

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

type Conmon_ServeAttachContainerResponse capnp.Struct

// Conmon_ServeAttachContainerResponse_TypeID is the unique identifier for the type Conmon_ServeAttachContainerResponse.
const Conmon_ServeAttachContainerResponse_TypeID = 0x94a72d9a2ccb9a30

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

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

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

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

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

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

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

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

func (s Conmon_ServeAttachContainerResponse) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_ServeAttachContainerResponse) Url() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_ServeAttachContainerResponse) HasUrl() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_ServeAttachContainerResponse) SetUrl(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

// Conmon_ServeAttachContainerResponse_List is a list of Conmon_ServeAttachContainerResponse.
type Conmon_ServeAttachContainerResponse_List = capnp.StructList[Conmon_ServeAttachContainerResponse]

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

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

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

type Conmon_ServePortForwardContainerRequest capnp.Struct

// Conmon_ServePortForwardContainerRequest_TypeID is the unique identifier for the type Conmon_ServePortForwardContainerRequest.
const Conmon_ServePortForwardContainerRequest_TypeID = 0xc865d8a1122038c5

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

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

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

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

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

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

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

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

func (s Conmon_ServePortForwardContainerRequest) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_ServePortForwardContainerRequest) Metadata() (Conmon_TextTextMapEntry_List, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_TextTextMapEntry_List(p.List()), err
}

func (s Conmon_ServePortForwardContainerRequest) HasMetadata() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_ServePortForwardContainerRequest) SetMetadata(v Conmon_TextTextMapEntry_List) error {
	return capnp.Struct(s).SetPtr(0, v.ToPtr())
}

// NewMetadata sets the metadata field to a newly
// allocated Conmon_TextTextMapEntry_List, preferring placement in s's segment.
func (s Conmon_ServePortForwardContainerRequest) NewMetadata(n int32) (Conmon_TextTextMapEntry_List, error) {
	l, err := NewConmon_TextTextMapEntry_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Conmon_TextTextMapEntry_List{}, err
	}
	err = capnp.Struct(s).SetPtr(0, l.ToPtr())
	return l, err
}
func (s Conmon_ServePortForwardContainerRequest) NetNsPath() (string, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.Text(), err
}

func (s Conmon_ServePortForwardContainerRequest) HasNetNsPath() bool {
	return capnp.Struct(s).HasPtr(1)
}

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

func (s Conmon_ServePortForwardContainerRequest) SetNetNsPath(v string) error {
	return capnp.Struct(s).SetText(1, v)
}

// Conmon_ServePortForwardContainerRequest_List is a list of Conmon_ServePortForwardContainerRequest.
type Conmon_ServePortForwardContainerRequest_List = capnp.StructList[Conmon_ServePortForwardContainerRequest]

// NewConmon_ServePortForwardContainerRequest creates a new list of Conmon_ServePortForwardContainerRequest.
func NewConmon_ServePortForwardContainerRequest_List(s *capnp.Segment, sz int32) (Conmon_ServePortForwardContainerRequest_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
	return capnp.StructList[Conmon_ServePortForwardContainerRequest](l), err
}

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

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

type Conmon_ServePortForwardContainerResponse capnp.Struct

// Conmon_ServePortForwardContainerResponse_TypeID is the unique identifier for the type Conmon_ServePortForwardContainerResponse.
const Conmon_ServePortForwardContainerResponse_TypeID = 0xf7507d1843e734e4

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

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

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

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

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

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

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

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

func (s Conmon_ServePortForwardContainerResponse) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_ServePortForwardContainerResponse) Url() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Conmon_ServePortForwardContainerResponse) HasUrl() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s Conmon_ServePortForwardContainerResponse) SetUrl(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

// Conmon_ServePortForwardContainerResponse_List is a list of Conmon_ServePortForwardContainerResponse.
type Conmon_ServePortForwardContainerResponse_List = capnp.StructList[Conmon_ServePortForwardContainerResponse]

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

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

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

type Conmon_version_Params capnp.Struct

// Conmon_version_Params_TypeID is the unique identifier for the type Conmon_version_Params.
const Conmon_version_Params_TypeID = 0xcc2f70676afee4e7

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

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

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

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

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

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

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

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

func (s Conmon_version_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_version_Params) Request() (Conmon_VersionRequest, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_VersionRequest(p.Struct()), err
}

func (s Conmon_version_Params) HasRequest() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_version_Params) SetRequest(v Conmon_VersionRequest) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRequest sets the request field to a newly
// allocated Conmon_VersionRequest struct, preferring placement in s's segment.
func (s Conmon_version_Params) NewRequest() (Conmon_VersionRequest, error) {
	ss, err := NewConmon_VersionRequest(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_VersionRequest{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_version_Params_List is a list of Conmon_version_Params.
type Conmon_version_Params_List = capnp.StructList[Conmon_version_Params]

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

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

func (f Conmon_version_Params_Future) Struct() (Conmon_version_Params, error) {
	p, err := f.Future.Ptr()
	return Conmon_version_Params(p.Struct()), err
}
func (p Conmon_version_Params_Future) Request() Conmon_VersionRequest_Future {
	return Conmon_VersionRequest_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_version_Results capnp.Struct

// Conmon_version_Results_TypeID is the unique identifier for the type Conmon_version_Results.
const Conmon_version_Results_TypeID = 0xe313695ea9477b30

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

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

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

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

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

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

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

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

func (s Conmon_version_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_version_Results) Response() (Conmon_VersionResponse, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_VersionResponse(p.Struct()), err
}

func (s Conmon_version_Results) HasResponse() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_version_Results) SetResponse(v Conmon_VersionResponse) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewResponse sets the response field to a newly
// allocated Conmon_VersionResponse struct, preferring placement in s's segment.
func (s Conmon_version_Results) NewResponse() (Conmon_VersionResponse, error) {
	ss, err := NewConmon_VersionResponse(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_VersionResponse{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_version_Results_List is a list of Conmon_version_Results.
type Conmon_version_Results_List = capnp.StructList[Conmon_version_Results]

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

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

func (f Conmon_version_Results_Future) Struct() (Conmon_version_Results, error) {
	p, err := f.Future.Ptr()
	return Conmon_version_Results(p.Struct()), err
}
func (p Conmon_version_Results_Future) Response() Conmon_VersionResponse_Future {
	return Conmon_VersionResponse_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_createContainer_Params capnp.Struct

// Conmon_createContainer_Params_TypeID is the unique identifier for the type Conmon_createContainer_Params.
const Conmon_createContainer_Params_TypeID = 0xf44732c48f949ab8

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

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

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

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

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

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

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

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

func (s Conmon_createContainer_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_createContainer_Params) Request() (Conmon_CreateContainerRequest, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_CreateContainerRequest(p.Struct()), err
}

func (s Conmon_createContainer_Params) HasRequest() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_createContainer_Params) SetRequest(v Conmon_CreateContainerRequest) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRequest sets the request field to a newly
// allocated Conmon_CreateContainerRequest struct, preferring placement in s's segment.
func (s Conmon_createContainer_Params) NewRequest() (Conmon_CreateContainerRequest, error) {
	ss, err := NewConmon_CreateContainerRequest(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_CreateContainerRequest{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_createContainer_Params_List is a list of Conmon_createContainer_Params.
type Conmon_createContainer_Params_List = capnp.StructList[Conmon_createContainer_Params]

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

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

func (f Conmon_createContainer_Params_Future) Struct() (Conmon_createContainer_Params, error) {
	p, err := f.Future.Ptr()
	return Conmon_createContainer_Params(p.Struct()), err
}
func (p Conmon_createContainer_Params_Future) Request() Conmon_CreateContainerRequest_Future {
	return Conmon_CreateContainerRequest_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_createContainer_Results capnp.Struct

// Conmon_createContainer_Results_TypeID is the unique identifier for the type Conmon_createContainer_Results.
const Conmon_createContainer_Results_TypeID = 0xceba3c1a97be15f8

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

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

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

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

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

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

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

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

func (s Conmon_createContainer_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_createContainer_Results) Response() (Conmon_CreateContainerResponse, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_CreateContainerResponse(p.Struct()), err
}

func (s Conmon_createContainer_Results) HasResponse() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_createContainer_Results) SetResponse(v Conmon_CreateContainerResponse) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewResponse sets the response field to a newly
// allocated Conmon_CreateContainerResponse struct, preferring placement in s's segment.
func (s Conmon_createContainer_Results) NewResponse() (Conmon_CreateContainerResponse, error) {
	ss, err := NewConmon_CreateContainerResponse(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_CreateContainerResponse{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_createContainer_Results_List is a list of Conmon_createContainer_Results.
type Conmon_createContainer_Results_List = capnp.StructList[Conmon_createContainer_Results]

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

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

func (f Conmon_createContainer_Results_Future) Struct() (Conmon_createContainer_Results, error) {
	p, err := f.Future.Ptr()
	return Conmon_createContainer_Results(p.Struct()), err
}
func (p Conmon_createContainer_Results_Future) Response() Conmon_CreateContainerResponse_Future {
	return Conmon_CreateContainerResponse_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_execSyncContainer_Params capnp.Struct

// Conmon_execSyncContainer_Params_TypeID is the unique identifier for the type Conmon_execSyncContainer_Params.
const Conmon_execSyncContainer_Params_TypeID = 0x83479da67279e173

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

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

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

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

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

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

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

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

func (s Conmon_execSyncContainer_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_execSyncContainer_Params) Request() (Conmon_ExecSyncContainerRequest, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_ExecSyncContainerRequest(p.Struct()), err
}

func (s Conmon_execSyncContainer_Params) HasRequest() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_execSyncContainer_Params) SetRequest(v Conmon_ExecSyncContainerRequest) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRequest sets the request field to a newly
// allocated Conmon_ExecSyncContainerRequest struct, preferring placement in s's segment.
func (s Conmon_execSyncContainer_Params) NewRequest() (Conmon_ExecSyncContainerRequest, error) {
	ss, err := NewConmon_ExecSyncContainerRequest(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_ExecSyncContainerRequest{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_execSyncContainer_Params_List is a list of Conmon_execSyncContainer_Params.
type Conmon_execSyncContainer_Params_List = capnp.StructList[Conmon_execSyncContainer_Params]

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

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

func (f Conmon_execSyncContainer_Params_Future) Struct() (Conmon_execSyncContainer_Params, error) {
	p, err := f.Future.Ptr()
	return Conmon_execSyncContainer_Params(p.Struct()), err
}
func (p Conmon_execSyncContainer_Params_Future) Request() Conmon_ExecSyncContainerRequest_Future {
	return Conmon_ExecSyncContainerRequest_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_execSyncContainer_Results capnp.Struct

// Conmon_execSyncContainer_Results_TypeID is the unique identifier for the type Conmon_execSyncContainer_Results.
const Conmon_execSyncContainer_Results_TypeID = 0xf8e86a5c0baa01bc

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

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

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

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

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

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

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

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

func (s Conmon_execSyncContainer_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_execSyncContainer_Results) Response() (Conmon_ExecSyncContainerResponse, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_ExecSyncContainerResponse(p.Struct()), err
}

func (s Conmon_execSyncContainer_Results) HasResponse() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_execSyncContainer_Results) SetResponse(v Conmon_ExecSyncContainerResponse) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewResponse sets the response field to a newly
// allocated Conmon_ExecSyncContainerResponse struct, preferring placement in s's segment.
func (s Conmon_execSyncContainer_Results) NewResponse() (Conmon_ExecSyncContainerResponse, error) {
	ss, err := NewConmon_ExecSyncContainerResponse(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_ExecSyncContainerResponse{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_execSyncContainer_Results_List is a list of Conmon_execSyncContainer_Results.
type Conmon_execSyncContainer_Results_List = capnp.StructList[Conmon_execSyncContainer_Results]

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

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

func (f Conmon_execSyncContainer_Results_Future) Struct() (Conmon_execSyncContainer_Results, error) {
	p, err := f.Future.Ptr()
	return Conmon_execSyncContainer_Results(p.Struct()), err
}
func (p Conmon_execSyncContainer_Results_Future) Response() Conmon_ExecSyncContainerResponse_Future {
	return Conmon_ExecSyncContainerResponse_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_attachContainer_Params capnp.Struct

// Conmon_attachContainer_Params_TypeID is the unique identifier for the type Conmon_attachContainer_Params.
const Conmon_attachContainer_Params_TypeID = 0xaa2f3c8ad1c3af24

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

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

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

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

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

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

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

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

func (s Conmon_attachContainer_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_attachContainer_Params) Request() (Conmon_AttachRequest, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_AttachRequest(p.Struct()), err
}

func (s Conmon_attachContainer_Params) HasRequest() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_attachContainer_Params) SetRequest(v Conmon_AttachRequest) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRequest sets the request field to a newly
// allocated Conmon_AttachRequest struct, preferring placement in s's segment.
func (s Conmon_attachContainer_Params) NewRequest() (Conmon_AttachRequest, error) {
	ss, err := NewConmon_AttachRequest(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_AttachRequest{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_attachContainer_Params_List is a list of Conmon_attachContainer_Params.
type Conmon_attachContainer_Params_List = capnp.StructList[Conmon_attachContainer_Params]

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

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

func (f Conmon_attachContainer_Params_Future) Struct() (Conmon_attachContainer_Params, error) {
	p, err := f.Future.Ptr()
	return Conmon_attachContainer_Params(p.Struct()), err
}
func (p Conmon_attachContainer_Params_Future) Request() Conmon_AttachRequest_Future {
	return Conmon_AttachRequest_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_attachContainer_Results capnp.Struct

// Conmon_attachContainer_Results_TypeID is the unique identifier for the type Conmon_attachContainer_Results.
const Conmon_attachContainer_Results_TypeID = 0xc5e65eec3dcf5b10

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

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

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

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

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

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

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

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

func (s Conmon_attachContainer_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_attachContainer_Results) Response() (Conmon_AttachResponse, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_AttachResponse(p.Struct()), err
}

func (s Conmon_attachContainer_Results) HasResponse() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_attachContainer_Results) SetResponse(v Conmon_AttachResponse) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewResponse sets the response field to a newly
// allocated Conmon_AttachResponse struct, preferring placement in s's segment.
func (s Conmon_attachContainer_Results) NewResponse() (Conmon_AttachResponse, error) {
	ss, err := NewConmon_AttachResponse(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_AttachResponse{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_attachContainer_Results_List is a list of Conmon_attachContainer_Results.
type Conmon_attachContainer_Results_List = capnp.StructList[Conmon_attachContainer_Results]

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

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

func (f Conmon_attachContainer_Results_Future) Struct() (Conmon_attachContainer_Results, error) {
	p, err := f.Future.Ptr()
	return Conmon_attachContainer_Results(p.Struct()), err
}
func (p Conmon_attachContainer_Results_Future) Response() Conmon_AttachResponse_Future {
	return Conmon_AttachResponse_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_reopenLogContainer_Params capnp.Struct

// Conmon_reopenLogContainer_Params_TypeID is the unique identifier for the type Conmon_reopenLogContainer_Params.
const Conmon_reopenLogContainer_Params_TypeID = 0xe5ea916eb0c31336

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

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

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

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

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

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

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

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

func (s Conmon_reopenLogContainer_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_reopenLogContainer_Params) Request() (Conmon_ReopenLogRequest, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_ReopenLogRequest(p.Struct()), err
}

func (s Conmon_reopenLogContainer_Params) HasRequest() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_reopenLogContainer_Params) SetRequest(v Conmon_ReopenLogRequest) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRequest sets the request field to a newly
// allocated Conmon_ReopenLogRequest struct, preferring placement in s's segment.
func (s Conmon_reopenLogContainer_Params) NewRequest() (Conmon_ReopenLogRequest, error) {
	ss, err := NewConmon_ReopenLogRequest(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_ReopenLogRequest{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_reopenLogContainer_Params_List is a list of Conmon_reopenLogContainer_Params.
type Conmon_reopenLogContainer_Params_List = capnp.StructList[Conmon_reopenLogContainer_Params]

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

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

func (f Conmon_reopenLogContainer_Params_Future) Struct() (Conmon_reopenLogContainer_Params, error) {
	p, err := f.Future.Ptr()
	return Conmon_reopenLogContainer_Params(p.Struct()), err
}
func (p Conmon_reopenLogContainer_Params_Future) Request() Conmon_ReopenLogRequest_Future {
	return Conmon_ReopenLogRequest_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_reopenLogContainer_Results capnp.Struct

// Conmon_reopenLogContainer_Results_TypeID is the unique identifier for the type Conmon_reopenLogContainer_Results.
const Conmon_reopenLogContainer_Results_TypeID = 0xa0ef8355b64ee985

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

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

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

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

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

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

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

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

func (s Conmon_reopenLogContainer_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_reopenLogContainer_Results) Response() (Conmon_ReopenLogResponse, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_ReopenLogResponse(p.Struct()), err
}

func (s Conmon_reopenLogContainer_Results) HasResponse() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_reopenLogContainer_Results) SetResponse(v Conmon_ReopenLogResponse) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewResponse sets the response field to a newly
// allocated Conmon_ReopenLogResponse struct, preferring placement in s's segment.
func (s Conmon_reopenLogContainer_Results) NewResponse() (Conmon_ReopenLogResponse, error) {
	ss, err := NewConmon_ReopenLogResponse(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_ReopenLogResponse{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_reopenLogContainer_Results_List is a list of Conmon_reopenLogContainer_Results.
type Conmon_reopenLogContainer_Results_List = capnp.StructList[Conmon_reopenLogContainer_Results]

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

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

func (f Conmon_reopenLogContainer_Results_Future) Struct() (Conmon_reopenLogContainer_Results, error) {
	p, err := f.Future.Ptr()
	return Conmon_reopenLogContainer_Results(p.Struct()), err
}
func (p Conmon_reopenLogContainer_Results_Future) Response() Conmon_ReopenLogResponse_Future {
	return Conmon_ReopenLogResponse_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_setWindowSizeContainer_Params capnp.Struct

// Conmon_setWindowSizeContainer_Params_TypeID is the unique identifier for the type Conmon_setWindowSizeContainer_Params.
const Conmon_setWindowSizeContainer_Params_TypeID = 0xc76ccd4502bb61e7

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

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

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

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

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

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

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

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

func (s Conmon_setWindowSizeContainer_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_setWindowSizeContainer_Params) Request() (Conmon_SetWindowSizeRequest, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_SetWindowSizeRequest(p.Struct()), err
}

func (s Conmon_setWindowSizeContainer_Params) HasRequest() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_setWindowSizeContainer_Params) SetRequest(v Conmon_SetWindowSizeRequest) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRequest sets the request field to a newly
// allocated Conmon_SetWindowSizeRequest struct, preferring placement in s's segment.
func (s Conmon_setWindowSizeContainer_Params) NewRequest() (Conmon_SetWindowSizeRequest, error) {
	ss, err := NewConmon_SetWindowSizeRequest(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_SetWindowSizeRequest{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_setWindowSizeContainer_Params_List is a list of Conmon_setWindowSizeContainer_Params.
type Conmon_setWindowSizeContainer_Params_List = capnp.StructList[Conmon_setWindowSizeContainer_Params]

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

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

func (f Conmon_setWindowSizeContainer_Params_Future) Struct() (Conmon_setWindowSizeContainer_Params, error) {
	p, err := f.Future.Ptr()
	return Conmon_setWindowSizeContainer_Params(p.Struct()), err
}
func (p Conmon_setWindowSizeContainer_Params_Future) Request() Conmon_SetWindowSizeRequest_Future {
	return Conmon_SetWindowSizeRequest_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_setWindowSizeContainer_Results capnp.Struct

// Conmon_setWindowSizeContainer_Results_TypeID is the unique identifier for the type Conmon_setWindowSizeContainer_Results.
const Conmon_setWindowSizeContainer_Results_TypeID = 0xe00e522611477055

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

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

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

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

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

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

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

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

func (s Conmon_setWindowSizeContainer_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_setWindowSizeContainer_Results) Response() (Conmon_SetWindowSizeResponse, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_SetWindowSizeResponse(p.Struct()), err
}

func (s Conmon_setWindowSizeContainer_Results) HasResponse() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_setWindowSizeContainer_Results) SetResponse(v Conmon_SetWindowSizeResponse) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewResponse sets the response field to a newly
// allocated Conmon_SetWindowSizeResponse struct, preferring placement in s's segment.
func (s Conmon_setWindowSizeContainer_Results) NewResponse() (Conmon_SetWindowSizeResponse, error) {
	ss, err := NewConmon_SetWindowSizeResponse(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_SetWindowSizeResponse{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_setWindowSizeContainer_Results_List is a list of Conmon_setWindowSizeContainer_Results.
type Conmon_setWindowSizeContainer_Results_List = capnp.StructList[Conmon_setWindowSizeContainer_Results]

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

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

func (f Conmon_setWindowSizeContainer_Results_Future) Struct() (Conmon_setWindowSizeContainer_Results, error) {
	p, err := f.Future.Ptr()
	return Conmon_setWindowSizeContainer_Results(p.Struct()), err
}
func (p Conmon_setWindowSizeContainer_Results_Future) Response() Conmon_SetWindowSizeResponse_Future {
	return Conmon_SetWindowSizeResponse_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_createNamespaces_Params capnp.Struct

// Conmon_createNamespaces_Params_TypeID is the unique identifier for the type Conmon_createNamespaces_Params.
const Conmon_createNamespaces_Params_TypeID = 0x8b4c03a0662a38dc

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

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

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

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

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

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

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

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

func (s Conmon_createNamespaces_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_createNamespaces_Params) Request() (Conmon_CreateNamespacesRequest, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_CreateNamespacesRequest(p.Struct()), err
}

func (s Conmon_createNamespaces_Params) HasRequest() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_createNamespaces_Params) SetRequest(v Conmon_CreateNamespacesRequest) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRequest sets the request field to a newly
// allocated Conmon_CreateNamespacesRequest struct, preferring placement in s's segment.
func (s Conmon_createNamespaces_Params) NewRequest() (Conmon_CreateNamespacesRequest, error) {
	ss, err := NewConmon_CreateNamespacesRequest(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_CreateNamespacesRequest{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_createNamespaces_Params_List is a list of Conmon_createNamespaces_Params.
type Conmon_createNamespaces_Params_List = capnp.StructList[Conmon_createNamespaces_Params]

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

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

func (f Conmon_createNamespaces_Params_Future) Struct() (Conmon_createNamespaces_Params, error) {
	p, err := f.Future.Ptr()
	return Conmon_createNamespaces_Params(p.Struct()), err
}
func (p Conmon_createNamespaces_Params_Future) Request() Conmon_CreateNamespacesRequest_Future {
	return Conmon_CreateNamespacesRequest_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_createNamespaces_Results capnp.Struct

// Conmon_createNamespaces_Results_TypeID is the unique identifier for the type Conmon_createNamespaces_Results.
const Conmon_createNamespaces_Results_TypeID = 0x8aef91973dc8a4f5

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

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

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

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

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

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

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

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

func (s Conmon_createNamespaces_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_createNamespaces_Results) Response() (Conmon_CreateNamespacesResponse, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_CreateNamespacesResponse(p.Struct()), err
}

func (s Conmon_createNamespaces_Results) HasResponse() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_createNamespaces_Results) SetResponse(v Conmon_CreateNamespacesResponse) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewResponse sets the response field to a newly
// allocated Conmon_CreateNamespacesResponse struct, preferring placement in s's segment.
func (s Conmon_createNamespaces_Results) NewResponse() (Conmon_CreateNamespacesResponse, error) {
	ss, err := NewConmon_CreateNamespacesResponse(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_CreateNamespacesResponse{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_createNamespaces_Results_List is a list of Conmon_createNamespaces_Results.
type Conmon_createNamespaces_Results_List = capnp.StructList[Conmon_createNamespaces_Results]

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

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

func (f Conmon_createNamespaces_Results_Future) Struct() (Conmon_createNamespaces_Results, error) {
	p, err := f.Future.Ptr()
	return Conmon_createNamespaces_Results(p.Struct()), err
}
func (p Conmon_createNamespaces_Results_Future) Response() Conmon_CreateNamespacesResponse_Future {
	return Conmon_CreateNamespacesResponse_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_startFdSocket_Params capnp.Struct

// Conmon_startFdSocket_Params_TypeID is the unique identifier for the type Conmon_startFdSocket_Params.
const Conmon_startFdSocket_Params_TypeID = 0xce733f0914c80b6b

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

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

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

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

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

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

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

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

func (s Conmon_startFdSocket_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_startFdSocket_Params) Request() (Conmon_StartFdSocketRequest, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_StartFdSocketRequest(p.Struct()), err
}

func (s Conmon_startFdSocket_Params) HasRequest() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_startFdSocket_Params) SetRequest(v Conmon_StartFdSocketRequest) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRequest sets the request field to a newly
// allocated Conmon_StartFdSocketRequest struct, preferring placement in s's segment.
func (s Conmon_startFdSocket_Params) NewRequest() (Conmon_StartFdSocketRequest, error) {
	ss, err := NewConmon_StartFdSocketRequest(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_StartFdSocketRequest{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_startFdSocket_Params_List is a list of Conmon_startFdSocket_Params.
type Conmon_startFdSocket_Params_List = capnp.StructList[Conmon_startFdSocket_Params]

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

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

func (f Conmon_startFdSocket_Params_Future) Struct() (Conmon_startFdSocket_Params, error) {
	p, err := f.Future.Ptr()
	return Conmon_startFdSocket_Params(p.Struct()), err
}
func (p Conmon_startFdSocket_Params_Future) Request() Conmon_StartFdSocketRequest_Future {
	return Conmon_StartFdSocketRequest_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_startFdSocket_Results capnp.Struct

// Conmon_startFdSocket_Results_TypeID is the unique identifier for the type Conmon_startFdSocket_Results.
const Conmon_startFdSocket_Results_TypeID = 0xf4e3e92ae0815f15

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

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

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

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

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

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

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

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

func (s Conmon_startFdSocket_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_startFdSocket_Results) Response() (Conmon_StartFdSocketResponse, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_StartFdSocketResponse(p.Struct()), err
}

func (s Conmon_startFdSocket_Results) HasResponse() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_startFdSocket_Results) SetResponse(v Conmon_StartFdSocketResponse) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewResponse sets the response field to a newly
// allocated Conmon_StartFdSocketResponse struct, preferring placement in s's segment.
func (s Conmon_startFdSocket_Results) NewResponse() (Conmon_StartFdSocketResponse, error) {
	ss, err := NewConmon_StartFdSocketResponse(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_StartFdSocketResponse{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_startFdSocket_Results_List is a list of Conmon_startFdSocket_Results.
type Conmon_startFdSocket_Results_List = capnp.StructList[Conmon_startFdSocket_Results]

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

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

func (f Conmon_startFdSocket_Results_Future) Struct() (Conmon_startFdSocket_Results, error) {
	p, err := f.Future.Ptr()
	return Conmon_startFdSocket_Results(p.Struct()), err
}
func (p Conmon_startFdSocket_Results_Future) Response() Conmon_StartFdSocketResponse_Future {
	return Conmon_StartFdSocketResponse_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_serveExecContainer_Params capnp.Struct

// Conmon_serveExecContainer_Params_TypeID is the unique identifier for the type Conmon_serveExecContainer_Params.
const Conmon_serveExecContainer_Params_TypeID = 0x90a3950a51412b8b

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

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

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

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

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

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

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

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

func (s Conmon_serveExecContainer_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_serveExecContainer_Params) Request() (Conmon_ServeExecContainerRequest, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_ServeExecContainerRequest(p.Struct()), err
}

func (s Conmon_serveExecContainer_Params) HasRequest() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_serveExecContainer_Params) SetRequest(v Conmon_ServeExecContainerRequest) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRequest sets the request field to a newly
// allocated Conmon_ServeExecContainerRequest struct, preferring placement in s's segment.
func (s Conmon_serveExecContainer_Params) NewRequest() (Conmon_ServeExecContainerRequest, error) {
	ss, err := NewConmon_ServeExecContainerRequest(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_ServeExecContainerRequest{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_serveExecContainer_Params_List is a list of Conmon_serveExecContainer_Params.
type Conmon_serveExecContainer_Params_List = capnp.StructList[Conmon_serveExecContainer_Params]

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

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

func (f Conmon_serveExecContainer_Params_Future) Struct() (Conmon_serveExecContainer_Params, error) {
	p, err := f.Future.Ptr()
	return Conmon_serveExecContainer_Params(p.Struct()), err
}
func (p Conmon_serveExecContainer_Params_Future) Request() Conmon_ServeExecContainerRequest_Future {
	return Conmon_ServeExecContainerRequest_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_serveExecContainer_Results capnp.Struct

// Conmon_serveExecContainer_Results_TypeID is the unique identifier for the type Conmon_serveExecContainer_Results.
const Conmon_serveExecContainer_Results_TypeID = 0xdebaeed2a782ac80

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

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

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

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

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

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

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

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

func (s Conmon_serveExecContainer_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_serveExecContainer_Results) Response() (Conmon_ServeExecContainerResponse, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_ServeExecContainerResponse(p.Struct()), err
}

func (s Conmon_serveExecContainer_Results) HasResponse() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_serveExecContainer_Results) SetResponse(v Conmon_ServeExecContainerResponse) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewResponse sets the response field to a newly
// allocated Conmon_ServeExecContainerResponse struct, preferring placement in s's segment.
func (s Conmon_serveExecContainer_Results) NewResponse() (Conmon_ServeExecContainerResponse, error) {
	ss, err := NewConmon_ServeExecContainerResponse(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_ServeExecContainerResponse{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_serveExecContainer_Results_List is a list of Conmon_serveExecContainer_Results.
type Conmon_serveExecContainer_Results_List = capnp.StructList[Conmon_serveExecContainer_Results]

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

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

func (f Conmon_serveExecContainer_Results_Future) Struct() (Conmon_serveExecContainer_Results, error) {
	p, err := f.Future.Ptr()
	return Conmon_serveExecContainer_Results(p.Struct()), err
}
func (p Conmon_serveExecContainer_Results_Future) Response() Conmon_ServeExecContainerResponse_Future {
	return Conmon_ServeExecContainerResponse_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_serveAttachContainer_Params capnp.Struct

// Conmon_serveAttachContainer_Params_TypeID is the unique identifier for the type Conmon_serveAttachContainer_Params.
const Conmon_serveAttachContainer_Params_TypeID = 0xa3cb406c522dcab1

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

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

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

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

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

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

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

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

func (s Conmon_serveAttachContainer_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_serveAttachContainer_Params) Request() (Conmon_ServeAttachContainerRequest, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_ServeAttachContainerRequest(p.Struct()), err
}

func (s Conmon_serveAttachContainer_Params) HasRequest() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_serveAttachContainer_Params) SetRequest(v Conmon_ServeAttachContainerRequest) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRequest sets the request field to a newly
// allocated Conmon_ServeAttachContainerRequest struct, preferring placement in s's segment.
func (s Conmon_serveAttachContainer_Params) NewRequest() (Conmon_ServeAttachContainerRequest, error) {
	ss, err := NewConmon_ServeAttachContainerRequest(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_ServeAttachContainerRequest{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_serveAttachContainer_Params_List is a list of Conmon_serveAttachContainer_Params.
type Conmon_serveAttachContainer_Params_List = capnp.StructList[Conmon_serveAttachContainer_Params]

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

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

func (f Conmon_serveAttachContainer_Params_Future) Struct() (Conmon_serveAttachContainer_Params, error) {
	p, err := f.Future.Ptr()
	return Conmon_serveAttachContainer_Params(p.Struct()), err
}
func (p Conmon_serveAttachContainer_Params_Future) Request() Conmon_ServeAttachContainerRequest_Future {
	return Conmon_ServeAttachContainerRequest_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_serveAttachContainer_Results capnp.Struct

// Conmon_serveAttachContainer_Results_TypeID is the unique identifier for the type Conmon_serveAttachContainer_Results.
const Conmon_serveAttachContainer_Results_TypeID = 0xedd2e5b018f17bbb

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

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

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

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

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

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

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

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

func (s Conmon_serveAttachContainer_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_serveAttachContainer_Results) Response() (Conmon_ServeAttachContainerResponse, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_ServeAttachContainerResponse(p.Struct()), err
}

func (s Conmon_serveAttachContainer_Results) HasResponse() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_serveAttachContainer_Results) SetResponse(v Conmon_ServeAttachContainerResponse) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewResponse sets the response field to a newly
// allocated Conmon_ServeAttachContainerResponse struct, preferring placement in s's segment.
func (s Conmon_serveAttachContainer_Results) NewResponse() (Conmon_ServeAttachContainerResponse, error) {
	ss, err := NewConmon_ServeAttachContainerResponse(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_ServeAttachContainerResponse{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_serveAttachContainer_Results_List is a list of Conmon_serveAttachContainer_Results.
type Conmon_serveAttachContainer_Results_List = capnp.StructList[Conmon_serveAttachContainer_Results]

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

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

func (f Conmon_serveAttachContainer_Results_Future) Struct() (Conmon_serveAttachContainer_Results, error) {
	p, err := f.Future.Ptr()
	return Conmon_serveAttachContainer_Results(p.Struct()), err
}
func (p Conmon_serveAttachContainer_Results_Future) Response() Conmon_ServeAttachContainerResponse_Future {
	return Conmon_ServeAttachContainerResponse_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_servePortForwardContainer_Params capnp.Struct

// Conmon_servePortForwardContainer_Params_TypeID is the unique identifier for the type Conmon_servePortForwardContainer_Params.
const Conmon_servePortForwardContainer_Params_TypeID = 0x9d82529754851252

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

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

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

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

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

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

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

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

func (s Conmon_servePortForwardContainer_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_servePortForwardContainer_Params) Request() (Conmon_ServePortForwardContainerRequest, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_ServePortForwardContainerRequest(p.Struct()), err
}

func (s Conmon_servePortForwardContainer_Params) HasRequest() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_servePortForwardContainer_Params) SetRequest(v Conmon_ServePortForwardContainerRequest) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRequest sets the request field to a newly
// allocated Conmon_ServePortForwardContainerRequest struct, preferring placement in s's segment.
func (s Conmon_servePortForwardContainer_Params) NewRequest() (Conmon_ServePortForwardContainerRequest, error) {
	ss, err := NewConmon_ServePortForwardContainerRequest(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_ServePortForwardContainerRequest{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_servePortForwardContainer_Params_List is a list of Conmon_servePortForwardContainer_Params.
type Conmon_servePortForwardContainer_Params_List = capnp.StructList[Conmon_servePortForwardContainer_Params]

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

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

func (f Conmon_servePortForwardContainer_Params_Future) Struct() (Conmon_servePortForwardContainer_Params, error) {
	p, err := f.Future.Ptr()
	return Conmon_servePortForwardContainer_Params(p.Struct()), err
}
func (p Conmon_servePortForwardContainer_Params_Future) Request() Conmon_ServePortForwardContainerRequest_Future {
	return Conmon_ServePortForwardContainerRequest_Future{Future: p.Future.Field(0, nil)}
}

type Conmon_servePortForwardContainer_Results capnp.Struct

// Conmon_servePortForwardContainer_Results_TypeID is the unique identifier for the type Conmon_servePortForwardContainer_Results.
const Conmon_servePortForwardContainer_Results_TypeID = 0xae5e0ae5001ebdfe

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

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

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

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

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

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

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

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

func (s Conmon_servePortForwardContainer_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Conmon_servePortForwardContainer_Results) Response() (Conmon_ServePortForwardContainerResponse, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Conmon_ServePortForwardContainerResponse(p.Struct()), err
}

func (s Conmon_servePortForwardContainer_Results) HasResponse() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Conmon_servePortForwardContainer_Results) SetResponse(v Conmon_ServePortForwardContainerResponse) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewResponse sets the response field to a newly
// allocated Conmon_ServePortForwardContainerResponse struct, preferring placement in s's segment.
func (s Conmon_servePortForwardContainer_Results) NewResponse() (Conmon_ServePortForwardContainerResponse, error) {
	ss, err := NewConmon_ServePortForwardContainerResponse(capnp.Struct(s).Segment())
	if err != nil {
		return Conmon_ServePortForwardContainerResponse{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Conmon_servePortForwardContainer_Results_List is a list of Conmon_servePortForwardContainer_Results.
type Conmon_servePortForwardContainer_Results_List = capnp.StructList[Conmon_servePortForwardContainer_Results]

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

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

func (f Conmon_servePortForwardContainer_Results_Future) Struct() (Conmon_servePortForwardContainer_Results, error) {
	p, err := f.Future.Ptr()
	return Conmon_servePortForwardContainer_Results(p.Struct()), err
}
func (p Conmon_servePortForwardContainer_Results_Future) Response() Conmon_ServePortForwardContainerResponse_Future {
	return Conmon_ServePortForwardContainerResponse_Future{Future: p.Future.Field(0, nil)}
}

const schema_ffaaf7385bc4adad = "x\xda\xc4z}t\x14e\x96\xf7\xbdUI*\x09\xe9" +
	"t\x8a\xea\xcc\x8b11\x04\x02o\x92!\xc3G`\x05" +
	"\x0e\x1c\x12 \xb20\xa0\xa94\xea\x0a3.Ew\x11" +
	"\x1a:\xddMU5\x10\xd4E\x9deu\xf0c\x84\xc5" +
	"\xa3p\x86s\xc4o\x18P\x9c\x19\x1cE\x99#\x8c\x1e" +
	"\x11u\xd7\xb0\x8b\xab\x1eqQ`\x14\x8e\xa88z\x04" +
	"\x0eX{\xee\xd3]\x1f]i\xa1;rv\xff\xc8I" +
	"\xf7\xad[\xf7>\xcf}\xee\xe7\xef\xe9Q{\xcaZ\x0b" +
	"F\xfb\xbe\x1c\x08\x9c\xfcaa\x91\xa9\x7f\xdc\xa3=\xb9" +
	"y\xc6\xaf@\x1c\x8a\x00\x85(\x00\xb4\xfc\xb2\xe4\x13\x04" +
	"\x94\x96\x95L\x014\xbf}|\xff\xe4\x87\xd6}\xb9\xd6" +
	"\xcd\xb0.\xc5\xf0\x04c\xf8p|\xd3\xa2G\xf8\xd9\xf7" +
	"\xb8\x19\xde(\xf9\x80\x18\x0e3\x86\x7fZ\xe0\xdf\xf0\xaf" +
	"?\x99\xcf\x18\xcc\xd3-\x8b\x0eo\xfc\xec\xea?A\xa1" +
	"@\x8c\x17J>@\xe9\x8aR\xfaXY\xfa\x1b\x044" +
	"\xef\xf9i\x9b\\\xfa\xe0c\x0f\xb8\xc5};\xe0$\x89" +
	"+)#q\xa36\xbd9bS\xf3S\x1b<\xe2\x18" +
	"cc\x19\xc7I\xede\x02\x80\xd4\xc6\x98\xdf\xbcj\xd5" +
	"\x8d\xfe'\xefz8\x1b\xb3R\xf6\x09J\xb71\xe6\x1e" +
	"\xc6\xdc9p\xcd\xdc\x87:\xef\xdc\xecV\xbd\xa3l\x08" +
	"\x07(\xbd\xc6\x18\xd6\x9c\xb8\xf6\xf9\xeb\x7f\xf5\xe5#n" +
	"\x86\xe3e_\xd3\xda\xce2\x86\x8d\xf3?[\xda>\xd3" +
	"\xffh\xa6\xba\x02\xe2\xab\xf1mCi\x9cO\x00\xde|" +
	"\xee@sg\xb4\xf5\xcd\xc7\xdcbD\xdf9\x123\xcc" +
	"Gb~r\xee\xe8\xe3\xef\x06\xc7o\x05y(\xf6Y" +
	"v;\x09\xfa\xa5\x8f\x96}\x93o\x05\xa09n\xc5s" +
	"\x8b\xbf\x9etbk\xb6=\xee\xf2}\x8dR/c~" +
	"\x9b\x89\xae\x7f\xf6/\xbdk'\x8d\xdc\xe6\xd6}\xcaw" +
	"\x90tc91\xac}J\xfd\xff{w\xff\x9c\x188" +
	"G\x1a`K]\xf9Z\x94&\x94\x93\xa8q\xe5W\x03" +
	"\x9a+\x16\xec\x7fv\x95||{\x96\xcdN._\x8f" +
	"\xd2\xf5\xe5\xb4Yi\xfa\xa8\x17\xdfmi\xda\xe1\xdd\x0b" +
	"G|\xa3\x89o&\x93\xd9^\xfe,\xe0w\xdf\xef\xb9" +
	"\xeax\xe9\xcd\xcf\xb8\xcf\xbe\xbc\x89\x0e\xc0\xe7\xa7\xc5\x8d" +
	"\xdd\xf2\x87\xe7\xef\xffb\xe53$\x8c\xf3\xeeu\xb4\x7f" +
	"\x09J\xed\xfe\xff\x07 \xcd\xf1?\x0bh\xde\xd2{\xf2" +
	"\xe9\xfb\xefi\xdb\xe5U\xcd\xb3s\xf3\xefC\xe9\x82\x9f" +
	">\x9e\xf5\xd7\x92\xe7\xf1G\x8e\x95\xde\xdf6\xf2\xf9l" +
	"v\xac\x13\x0f\xa04Y\xa4\x85N\x10i%\xf6s\xb1" +
	"\x9a7w\xecxu\xfe\xf8\xef\xb6\x99d\xa6\x9b\xc4*" +
	"l\x89\x88\x7fB\x8a\x13\xe9uNZW)\x00\x98\x8d" +
	"\x9f\xdf\xfd\xe4]\xbf\x0b\xee\xce&\xbc\xa7r\x1f\xa6\xd8" +
	"\xa4\xfb*I\xf8\x81\xe7\xb7N<wt\xc5n\xef\xc2" +
	"\xe9\x1c[\xf6V\x1eD\xe90q\xb7\xbc_y\x17\x0f" +
	"hV\xcc\xff\xf7\xc9\x9f\xdf\xfc\xd7\xd7\xdcg:\xa7\x8a" +
	"E\xa0RE\xf2>U^\xe2\xda\xdf\x8e\xbe\xeefX" +
	"SUJv\xdd\xcc\x18^\x1b?x\xe0\x96\xf7\xd4\xfd" +
	"\x9e\xd5\xb13\xdaS5\x84\x93\x0eW\xd1\xea\xde\xaf\"" +
	"\x7f\xfb\x97g\x86\xaf\xf4\xdd\x7f\xef\x81\xac':\xe7\xca" +
	"s(E\xae\xa4\x8f\xea\x95\xcc\xac\x9f\x1e\xfb~IW" +
	"b\xe4[n\xe5\xbf\xae^O\xab\xdbXM\xca\x97\x0e" +
	"\xd8\x1f(\x99\xa2\xff\x9b\x9b\xe1\xc5\xea}\xc4\xf0\x06c" +
	"8S\xf9\xe7\x87\xaa&\xed\xce`8Q\xcd\xf6w\x81" +
	"1\xd4U\xff\xf5\x0e-R\xfdN\xd6\x83\xae\xab9\x89" +
	"\xd2\xe4\x1a\xfa8\xa1\xe6uZQU[\xefX\x7fl" +
	"\xc6;\x9e\xdd2\xeea\xb5\x8f\xa24\xb9\x96\x1dt-" +
	"9\xd1c\x7f{z\xc1\xaeu\x81w\xfb\xc4\xc3\x89\xda" +
	"%(]`\x9cgkW\x03\x9a\xe7\xd7L\xba\xbd\xa6" +
	"\xe6\xdd\xf7\xb3\xda\xa5y\xf0I\x94f\x0ef\x9e>\xf8" +
	"S@s\xd3OW$n^8\xf1#\x0f7\x0b\x9f" +
	"\xba\xba\x0fP\x9a\\\xc7\x16QG\x1b\xbc}\xfb\x9dO" +
	"\x1d\xfcb\xf7G\x19Y\xba\x8e%\x9ee\x8c\xe1\xfc\xc4" +
	"\xf3\x7f~dR\xe2\xbf\xbd\xba\x0b\x89\xf3\xc1\xba\xb5(" +
	"\xed q-[\xebn$\x0b\\\x9f\x98!\x0e\xef," +
	"?\xe2\x96W3t 9\xc4\xb8\xa1,\xc9\xde2c" +
	"\xeb\xcd\x11\xe9\xa8\x9b\xe1\xa6\xa1\x9bHa\x841\xfc\x9d" +
	"\xf4\x97\x9d\xb1u'\x8f\xbb\x19\xee\x1b\xca\xd2\xf4\x16\xc6" +
	"\xf0\xd2-\xa7\x07\xed<~\xf0\x94\x9ba\xefP\x8eT" +
	"\x1cb\x0c{\xe7\xb7t\xfc\xd7\xd1\xe1_\x81\xd8\xcc9" +
	"\x81\x0d\xd8rv\xe8z\x94\xc4z\xda\xbd\xaf\xfe:@" +
	"\xb3\xf7\x8b\xda\xedo\x1e\xff\xf9\xdf\xbc\x9b+aQ_" +
	"\xbf\x09\xa5\x99\xf5,3\xd6_\xcd\x01\x9aO.{\xec" +
	"\x813C\xc4o\xbcI\x82\xd9b\xe3\xf0OP\xda5" +
	"\x9c>>7\x9cy\xc3\x0b\x9b6\xfc\xe6\xd513\xbe" +
	"\xc9p\xbf\x06\x96\x11\xdfn\xa0\x85V\xfe\xe3\x1dG\x9a" +
	"N\x1c\xcd`8\xd5p\x80\xa5\xccFb86\xf6\xd3" +
	"i\x83n\xeb\xf8.[l\x0fkl\xe2\xa4\xf6FV" +
	"\x91\x18\xf3\xcb\xb8m\xc0/\x96|v\xc6-Mid" +
	"\x86K2\x863[~\xd7r\xfb\xdb\x7f8\x9b%\xad" +
	"nl<\x80\xd2\xaeFJ\xab\xeb\xffcV\xf7G\x17" +
	"^:\x97-b\xd75>\x8a\xd2V\xa6\xf3\x89\xc6\x15" +
	"\xd0lFb\x86\xaa\xc5\x94h\xd1\xc8\x84\x167\xe2#" +
	"C\xf1Xw<\xf6\xb3\x90\x92\x88%&NK}Q" +
	"W\xaa\xa1`O,4-\x1e3\x94HL\xd5\xea;" +
	"\x14MP\xbau\xb9\x80/\x00(@\x00\xd17\x15@" +
	".\xe6Q\x0ep\xb8ZS\x97%U\xdd\xc0\x0a\xc7\xe0" +
	"\x80X\x01\x98\x93\xba\x90\xa6*\x86z\xad\xd2\xad\xea\x09" +
	"%\xa4\xea\xf5\x9d\xaa\x9e\x14\xa2F\x86\xbaY\x00r\x19" +
	"\x8f\xf2 \x0eMM\xd5\x13\xf1\x98\xae\x02\x00V8u" +
	"\xfd\xc7\xa8\xecP4\x85\xcfe\x83v\x07\x93\x87\xb6i" +
	"\x1em\x9d$\x8d\xd7\x8d\x0eD\xb9\xdaV\xb8k!\x80" +
	"\xfcG\x1e\xe5W8\x14\x11\x03H\xc4=\xf3\x00\xe4\x97" +
	"y\x94\xdf\xe3P\xe4\xb8\x00r\x00\xe2!\xe2\xfcO\x1e" +
	"\xe5\xaf8\x14y>\x80<\x80x\x8a\x88\x9f\xf3\x18," +
	"F\x0e\xc5\x82\x82\x00\x16\x00H\x858\x0b X\x80<" +
	"\x06+\x88^X\x18\xc0B\x8a&\x1c\x03\x10,&z" +
	"\x80\xe8EE\x01,\x02\x90D\xc6_A\xf4\x11\xc8\xa1" +
	"\xd9\xad\x1aJX1\x14\x10\xae\x8b\x86\xd1\x07\x1c\xfa\x00" +
	"\xcdXz+\xc0\xab:\x96\x03v\xf0\x88~'=\x02" +
	"\x12\xd1LF\xc2s\x94D\"\x02B\xac\xcbf+\x03" +
	"\x8e=\xec\xba\xd8\xc3\x85\x8a\xaev(\xc6b:`\xa2" +
	"\x95\x01\xd6&\xe2\xe1\x99a\xeb\x9b\xb3.\x00\xeb\xe5\x0a" +
	"'\x10\xd2\x0b\xc8\xe5ltU[\xae\xb6\xafT3\x9c" +
	"\xdd\xaf\xe5\xe4\xecv\xad\xf1\xf8\x82p\x11}A\xd2\xd7" +
	"f\x18Jh\xb1\xad\xb1\xd3\xf2gr\x08\x97\xd6!\x8e" +
	"V!\xa9E\xed\xcd\xf7\xcf\xe7\xf4D\\\x88\xe9\xaaG" +
	"\xc7\xbct\\5p\xd9\x8f\xb5\xc2\xe9@=V\x15." +
	"e\xd5\x8e\xb8f\\\x13\xd7V(Z\xb8\x1f\x99\xc4\xee" +
	"C\xf2\x084M\x8d'\xd4\xd8\xecx\x97\xa3\xafS\xad" +
	"\xd5\x939\xe7\x12\xbbi\xf7(-\xbc\x88\xd2NK)" +
	"\x99\xd8\x1fO\x998w\xdf\xf3\xf8B\xfd\x14JE\xb9" +
	"\x18\xc8\xee\xbd\xf2X\xab\xed\x0f\xee\xb5\xca\xc5\xb6\xaa\xc6" +
	"&\x00\xb9\x9eGy\x14\x87V\x0aj&Z\x03\x8f\xf2" +
	"X\x0e\xfdFOB\xf5\x84\xba\x1f\xd0\x9fP\x8c\xc5y" +
	"\xb9g\xb0O\xd8u\xaazm\"\xde\xd7A\x7fL\x10" +
	"(\x1e\xdb2\xd3b\x0e\xb6\xb5{\xa8<l;\xadK" +
	"\x8b'\x13s\x94\x98\xd2\xa5j\xc0b\xb9\x98\xa5kq" +
	"*\x89\x11Kf\x01\xac\xd6{tC\xed\x0e\x9b!\xc6" +
	"\xbcH\x07\x80\x9c\x84\xa7\xbc$\x9d(0\xc3\xc3.\xf6" +
	"\xda\x0d\xaa\xa6G\xe21Vptd\x05\xa7\xcc\xde{" +
	";\xed\xbd\x95Gy\xb6s\xd83\xa9\x8a\xfc=\x8f\xf2" +
	"\\\xaa7\x98\xaa72\x05L\x07\x8fr\x94\xc3\xd5\xcb" +
	"Uma\\W\x11\x81C\x84\x1f\xaa\x10y\xe5\xe7\xfe" +
	"e\x92NU\xf7\xe7\x1e\xd9vc\xe69\xd1\x82\x8b\xe8" +
	"\x9e\x1d\xef\x9a\xae\xf9#\xcbUM.@w\x97\x8aM" +
	"\xfe\xb9=\x09\xd5m\xcb\xa6,\xb6$\xdat\x1e\xe5\x0e" +
	"\x97-\xe7Lu\x0clE\x93-8K4\xad\xeeV" +
	"V\x06#\xabT,\x01\x0eKr\x8e.\xe3\xc6H," +
	"\x1c_Ao\xa6\x0e\xdf`\x0e\x19\xb0\x17|[\x15\x80" +
	"\xbc\x92G\xf9\x9f\x9d\x05\xdf1\x06@\xbe\x95G\xf9n" +
	"\xd7\x82\xd7L\x04\x90o\xe7Q\xbe\x97\x9a\x0dL5\x1b" +
	"\xbf&7\xb9\x9bGy\x03\xf5\x1a\x1c\xeb5\xc4ud" +
	"\xfd\x07x\x94\xb7s\xc8G\xecZ]\xbb\"\x126\x16" +
	"\xa3\x00\x1c\x0a\x80S\x16\xab\x91\xae\xc5\x86\xf5\xf5r\xb8" +
	"\xcfE-a(\x9aqM8\x18\x0f-U\x0d\xbb\xce" +
	"z\x0bm\x93\x93\x04\xb2\xa72\xfe\x87T\xf0\xf1\x98\x1c" +
	"Et\xa0\x0d\xb1w\x953\xa4\x88\xbdw:\x03\xbc\xd8" +
	"\xbb\xdb\x99m\xc4C\x9d.x\xe5\x90\xe6\xcc\x80\xe2\xa1" +
	"}N\x17-\xbe\x7f\xc0\x99%\xc5\x8f\x0f:\x89I<" +
	"\xa1\xb9P\x97\x13\xab\\\x93\xec\x89\xb5.\xf0\xe9\xd4z" +
	"\x07\xfb\x10Oos\x8d\x14\xdf\xfe\xde\x05\xc7\x9d\xdd\xe7" +
	"\x9an/t\xba\xc0\xb2\x0b\x07\x9c\x0e@*\xc4\xf5\x0e" +
	"|!\x95\xe06\x07)\x91|\xf8{\xe7\x88$\x11\xd7" +
	":\xfd\x91T\x89\x07\x1dlJ\xaa\xc1\x0f\x9c\xea%\x0d" +
	"\xc3O\x1c Oj\xc6\x93N\xe9o\x19\x87\xa5\xae\x99" +
	"\xaa\xa5\x0d\x07\xa2i\xe54\x98\x92rl\x9b\xc0[\xc7" +
	"\x9b\xea}\x9c\xcab1\xb2x\x8e,W\x015\xd3\xca" +
	"\xd6P\xcb\xf2\xb5i\xbdS\xe8\xed\xc9\xda\xbd\xc3\x90\x15" +
	"O`Z\x8f8o'\x87\xaai%l\xa8M\xe9\xb6" +
	"\xbfOI\xc95\xad\xb6\x01\xbb\x1c\x81n\x9a%\xc8\x8a" +
	"e\xb4\x82\xd9\xcf\xe4y\xc9\xe9\xe2iZ}\x1f\x9f1" +
	"l\xe8\x06X\xa5\x1f\x1d\x1e.\xa39d\x81a:l" +
	"\xae%\xa4\x83\x08\xd3Qd-\xc1C\xb6\x960W]" +
	"i\xd0\x1f\xceQ\x12\xed1C\xeb\x010\xadz\xcfy" +
	"\xed\x88F\xf6g\xa4\x9b\xd7U\xd3\xea\x97\xb9\xcc\x86y" +
	"YRHY!\xeb\xd3to\x93z\xdc\x11\xd7\xf8>" +
	"\xd5\xc3\xb1\xf9\xc5x\xd2\x06\x90G\xf0\x85\x006z\x85" +
	"\x16\"\"\xc98\x158\xa9\x1d\x05t\xb0\x03\xb4 *" +
	"i\x02\xde\x09\x9c4\x1a\x05\xe4ll\x1d\xad\x99_\x1a" +
	"\x86\xeb\x81\x93\xeaP@\xdeFb\xd1\x82\xef\xa4J\xf6" +
	"\xae\x0f\x05,\xb0\xf1\x15\xb40g\x09q\x13p\xe2\x05" +
	"\x01\x0bm<\x0f-\x1cG<\xbd\x1b8\xf1\x94\x80E" +
	"6\x1c\x8f\x16p/~\xbc\x168\xf1\xb0\x80\x82\x8d\xb4" +
	"\xa1\x05i\x88\xbd\x1ap\xe2\x1b\x02\x16\xdb\xb8;ZX" +
	"\x93\xb8\x87\xf4\xbd(`\x89\x0dX\xa3\x05\xea\x88;\xb6" +
	"\x01'n\x15\xb0\xd4\x06\xcd\xf1\xfb=W\x01\xc3n7" +
	"\x1f\x04N\xdc,P\xd3@!\xda\x8af(\x1dg\x98" +
	"62\xb4\xa2i\xe1\x0dh\x99\x1e\xb5V4\xad\xe6\xcd" +
	"\xcd\xa9\xd9\x01\x92f\xe5Ub\xd53\x82aZ<6" +
	"%\xf5\x8a\xad\xefZ\x05-_\x07\x92\xa3\xa7]\x17j" +
	"\x99\xef2\x11)'\xc4\x90Gr\xca\xc1\xd0r0\x7f" +
	"Z\xae\xd5\x97p^\xb7\xa1\xb5\xe7:\x00x\xaa\x93S" +
	"\xa7\xb3\xb44\x0d\xdce,\x8b\xde\x0c\xe9\xea\x0f[-" +
	"\xd5\xd2sX\x05\x10\xdc\x8e<\x06_@\x07\x93\x90v" +
	"\xe1<\x80\xe0\x1f\x89\xfe\x0ar\x88)TB\xda\xc3\xa0" +
	"\x83\x97\x89\xbc\x1f\x9d^Az\x8dA\x0d\xaf\x10\xfd-" +
	"t\xda\x05\xe9\x0d\xec\x04\x08\xee'\xfa1\x06M\xf0)" +
	"h\xe2c\\\x02\x10<B\xf4\xf3\x0c\x9a(HA\x13" +
	"g\x99\xda3\x0c\xb2\xe08\x14\x85\xc2\x00\x0a\x00\x92\xc8" +
	"\x11\xbd\x82\xe318\x82\xe8\xc5E\x01,\x06\x90\x1a\x19" +
	"\xbd\x81\xe8\xd3\x89^\"\x04\xb0\x04@j\xe3\x16\x02\x04" +
	"[\x89\xfe\x0b\xa2\x97\x16\x07\xb0\x14@\xba\x89\xd1\xff\x81" +
	"\xe8a\xa2\x0f(\x09\xe0\x00\x00I\xe1h_\x0b\x88~" +
	"+\xd1\xcbJ\x03X\x06 \xf5pS\x01\x82\x06\xd1\x1f" +
	" \xba\x0f\x03\xe8\x03\x90\xee\xe34\x80\xe0\xbdD\x7f\x98" +
	"\xe8\xe5\x03\x02X\x0e =\xc8\xe8\x1b\x88\xbe\x93\xe8\xfe" +
	"\xb2\x00\xfa\x01\xa4\x1dL\xce\xd3D\x7f\x95\xcb\xe8\x9c\xcc" +
	"\x85\xc9X8\xaav(\xc0\xbbz\x12C\xd5\xba#1" +
	"%JN\x90n\xc2ku#\x1c\x89\xd9-\xb9\xba2" +
	"b0\xf8\x04\xfb +\xf1xw;=\x05\xbfb," +
	"\xee\xf34j\x15H^s\x01\x00.@\x96q\x85\xa2" +
	"\xaa\x12K&\xa6\x01\xdf\x1d\xee\x03\xebD\xe3\x0b\x95h" +
	"\x9b\x06|_T'\x14\xef\xeeVb\xe16\x10\xb4\xbe" +
	"\x0f\xfb\xdf\x07\xaeVc\xcboP\xdc\x0b\xf6FD(" +
	"\xb3\xd6\xa3\xdfi\xbdR\x1d\xb7\xa9\x84\xc3\x11#\x12\x8f" +
	"A\xad\x12\xbd&l\x8b*I-nuTU\x96\xf6" +
	"%\xf7k\x04\xedT\xf5d\x94\xcfuj\xb1;\xbc<" +
	"\x10&\xdd\xdd\xfc{f_\x1d\xe0\xd2\xc3\xaf\xdd/\xe6" +
	"\x0bke\x1b\xd3\xacR\xed\xc1\x19f\xa51\x85\xe9." +
	"\xac\xb3\xad\xd3\x99\xa1rKu1\xd5\xb8V\xefP\x0c" +
	"\xc0~\xa0\x0f^\x10.\xdd%z\xc6\xa4Y\xe9\x91\xe8" +
	"a\xd7B\x1f\xacJ\x0f:\xbf\xb5\xb3\x9f\xb8\x91f\xa7" +
	"\x0d<\xca\x8f\xb8\xc6\xa4\xcd4;=\xcc\xa3\xfc\xb8k" +
	"L\xdaB\xc4\xdf\xf2(?\x9d\xe36\xdd\xb3TF\xa0" +
	"O\xd1\x8dp<i\xb8\xbf\xaa\x9af\xa7\x81\\\x00\x82" +
	"ta\xce\x1d\x19\xb1\x07\x9d<`9\xdd]\xe6,G" +
	"\xbc\xb4*{\xd0\xc8\x1b\xd8\xefo\xb8\xd9CX\x1e\x1a" +
	"\xb3!Y\xa9\x06\x99<i\xb0\xad\xb6\x97\xd4\xbe\xc3\xa3" +
	"\xfc\xb9\xcb\x93N\x90'\x1dK#\xf9\x16\xbc\x7f\x8a\xcc" +
	"\xf1\x19\x8f\xc1\x02\xaa\xae)x_B\x1c\x02 \x9f\xb7" +
	"\xf1}\xb4\xf0\xfd1\x00\x9dT\x13\xcbX\x0d\xe5R5" +
	"\xb4\x04'f\xc0\xfeE|\xaa\x86\xfa\x18\xdd\x81\xfd\x05" +
	"L\xd7P\xd4,\xd8\xbf\x1a\xf3w\xcb\xd5\xe9\xd4\xeeI" +
	"\xea\x82a\xf4d/Q\x97\xf0\xdcK'\xec<\x81Y" +
	"'\x07\xb9 \x9b*'\xdd\x88\xd9\xf1/\xae/\xfe\xe5" +
	".\xcf\x97\x01\xbb(\xb8\x14X\xeb\xa7\xa6\x95\xe5$\xb6" +
	"\x94qC\x18\x96\xd8L\xff8q\x18\xfd\xe3\xc5\x9a&" +
	"\x00,\x10+\x87\x00\x08\x91DH\x88\xa9\x86\x90\x88\x84" +
	"\xfdI]\xd5\x84\xa4\xa1\xe7\xe4\xc7Y\xe6\\\x17D\\" +
	"a\x9bM!c,H\x19\xc3\xb2Z\x84RZ\x98G" +
	"9\xe1\x02\x8e\xba\x89\xb8\x98G\xd9\xa0\x8c88\x95\x11" +
	"\x97\xd1\xdb\x09\x1e\xe5[\xb9T\x9f2-\x1ef\xc1W" +
	"\x00\x1c\x168\x8e\x916\xa6\xe5\x18\x96m\x8dH\xb7\x1a" +
	"\xbe.i\xb8z\x9f\xfe\xf5\xbb\xe9\xf1\xd2\xd3k/q" +
	"e\x86P\x9a\x19\xfcZG$\x8c\xc5\xc0aq\xff\xef" +
	"\x94\xf2\xbb\x86\xb0\xa1\x92<\xe0g\x0b`H\xcf\xb5\xb4" +
	"\xb3A\xb6\xae\x8dU\xae\xead\x9d\xda\xe6yN!\xb2" +
	"}\xfd\x09\x0d@~\x9cGy\xa7\x9d{\xc4\x1d\xeb\x01" +
	"\xe4\x9d<\xca/S\xe6\xe1Se\xecE\x8a\x94\x17x" +
	"\x94_\xa5\xbcS\xc0\xf2\x8e\xb8\x97\xf6\xf4\x0a\x8f\xf2\x87" +
	"\x99\x91\xa2\xb3\xd4\xefid\xd9\xd8\xa7\xea:\xd4F\xe2" +
	"1\xd7\xdd\x9en\xc4\x13m\x8b\x0c\x15\xb5 \xe5\x8c\xf6" +
	"8.\xfa\xdfC\x9b\xb3\xf6N\xac\x8a\x18\x98\xe3\xe9\xd9" +
	"\x10[\x1e\xa7g\xd5\xe1\xfc\xea\x95\x0d4\xfe\xb8;\xb2" +
	"\x9c/<m\x8c1\xafv4\xcb%W\xca\xa0\x99M" +
	"\xc0\x0fo\xd3F\x07\xf30\xa8\x85\xf5i?\x9b\xdb\x93" +
	"`\x17&r\x19s\xf0\x9a\x83,\x83\xd65\xb1\x0cz" +
	"\xc5,\x00;\xd49\xad3\x19\xa3\x143\x93\x14,R" +
	"B\xa8\xfa\x97\xe8\xf1\x98\xb9$\x9e$}\xe1\\ok" +
	"\xeck\x17W\x9ai\xb0\xe7\xea\x126\xf8\xdaE\xd8\x1a" +
	"\xabE\xa49\xb0\x8c\xc8\x83\xd0\xc9\xa3R%U~\xa7" +
	"6\x8b<\x97\xea\x08\xae`\xb5<@\xf4\xc1\xe8\x04\xa6" +
	"T\xc3\xc4W\x13\xbd\x01\x9d\xd8\x94\x861\xfe\xc1\xd6\xd5" +
	"\xbeXT\x98\xea\x09\x1a\x91\xe6\xde\x06\xa2\x8fe=A" +
	"Q\xaa'\x18\xcd\xe6\xf0QD\x9fD\xf4b!5W" +
	"O`\xf2\xc7\x13}:\xd1K\x8a\xd3s5\x9b\xff[" +
	"\x89>\x9bz\x88\x84\x16\x0f\xa9\xba>\x13\xd0\xce\x9e\x16" +
	"\x0ed\x85\xba`(]\xd6\xe7)\xd4CD\x0c\xd7\xec" +
	"\x1b\x89\x86\xa7So\xaf\xda,\x86\xa2u\xa9\x0e\x8b\x96" +
	"\xd4\x0d25\x08.\x99fH\xd1\xba\xe27\xa8\x1a\xf8" +
	"\xf5>\xe4\xb9\x9a\xea\x92\x97\x917\xac\\\xd2\xcfZ\xe9" +
	"t\x18\xae\x96\x8f\xb2\xee[\xa9\x1foXI\xf7\xd0\xbc" +
	"\xf4o7\x8e\xb8J\xe5a\x0a\xb7\xf7x\x94\xbf\xa1\xf3" +
	"mMe\xdd\xd3\x14\x10_\xf1(\x9fw\x0d\x0fg)" +
	"\xeb\x9eI\xf7\x866d\x82d\xfaN\xdbC,\xc4\xe4" +
	"\x0a\xe6Q\xccCF\xa1\x0b1if\xdd\xde\x08\xa2\x8f" +
	"\xc7\xccDM\xde\x1fO\x1aA\xe0\xd5\x90u\xe5\xf4\x03" +
	"\xdd]6 \xe2\xffx\x8c\xef\xcf\x84\x90\xf3\xe4c_" +
	"\xe4\xf4{\xf2\xb1\xb2^\x8ei\xcf\xbeZ\xb9<s\xb8" +
	"\xab\x9b\xbbL\xd7\xeb}\x7f'\x96\xdf\x9d\xac}\xb3\x95" +
	"\xd7\xb8\x95q\xb5\xe9\xba\xd0\xcb)3[w\x13\xecj" +
	"B0\xb4\x1e\x0f.1\xc4\xf9\xfd\x83\xdd'5\x8fq" +
	"~\x00!,U{\xeca|\xb9\x12M\xda\xc9\xe4\x7f" +
	"\x02\x00\x00\xff\xff^\xc3g\x98"

func RegisterSchema(reg *schemas.Registry) {
	reg.Register(&schemas.Schema{
		String: schema_ffaaf7385bc4adad,
		Nodes: []uint64{
			0x83479da67279e173,
			0x8aef91973dc8a4f5,
			0x8b4c03a0662a38dc,
			0x8b5b1693940f607e,
			0x90a3950a51412b8b,
			0x94a72d9a2ccb9a30,
			0x9887a60f577a1ecb,
			0x9d82529754851252,
			0xa0ef8355b64ee985,
			0xa20f49456be85b99,
			0xa3cb406c522dcab1,
			0xa93853d6a4e3fa16,
			0xa9e93cf268b17735,
			0xaa2f3c8ad1c3af24,
			0xaa4bbac12765a78a,
			0xace5517aafc86077,
			0xad2a33d6b9304413,
			0xae5e0ae5001ebdfe,
			0xae78ee8eb6b3a134,
			0xb5418b8ea8ead17b,
			0xb62f418e0ae4e003,
			0xb737e899dd6633f1,
			0xba53ab87a688ec29,
			0xba77e3fa3aa9b6ca,
			0xc5e65eec3dcf5b10,
			0xc76ccd4502bb61e7,
			0xc865d8a1122038c5,
			0xca8c8e0d7826ae86,
			0xcc2f70676afee4e7,
			0xce733f0914c80b6b,
			0xceba3c1a97be15f8,
			0xd01c697281e61c21,
			0xd0476e0f34d1411a,
			0xd61491b560a8f3a3,
			0xd9d61d1d803c85fc,
			0xde3a625e70772b9a,
			0xdebaeed2a782ac80,
			0xdf703ca0befc3afc,
			0xe00e522611477055,
			0xe313695ea9477b30,
			0xe5ea916eb0c31336,
			0xedd2e5b018f17bbb,
			0xf026e3d750335bc1,
			0xf34be5cbac1feed1,
			0xf41122f890a371a6,
			0xf44732c48f949ab8,
			0xf4e3e92ae0815f15,
			0xf7507d1843e734e4,
			0xf8e86a5c0baa01bc,
			0xf9b3cd8033aba1f8,
			0xfabbfdde6d4ad392,
		},
		Compressed: true,
	})
}
