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

package httpovercapnp

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"
	bytestream "capnproto.org/go/capnp/v3/std/capnp/compat/bytestream"
	stream "capnproto.org/go/capnp/v3/std/capnp/stream"
	context "context"
	strconv "strconv"
)

const CommonText = uint64(0x857745131db6fc83)

type HttpService capnp.Client

// HttpService_TypeID is the unique identifier for the type HttpService.
const HttpService_TypeID = 0x92963bfdad2beb6a

func (c HttpService) StartRequest(ctx context.Context, params func(HttpService_startRequest_Params) error) (HttpService_startRequest_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0x92963bfdad2beb6a,
			MethodID:      0,
			InterfaceName: "http-over-capnp.capnp:HttpService",
			MethodName:    "startRequest",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 2}
		s.PlaceArgs = func(s capnp.Struct) error { return params(HttpService_startRequest_Params(s)) }
	}

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

}

func (c HttpService) Request(ctx context.Context, params func(HttpService_request_Params) error) (HttpService_request_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0x92963bfdad2beb6a,
			MethodID:      1,
			InterfaceName: "http-over-capnp.capnp:HttpService",
			MethodName:    "request",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 2}
		s.PlaceArgs = func(s capnp.Struct) error { return params(HttpService_request_Params(s)) }
	}

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

}

func (c HttpService) Connect(ctx context.Context, params func(HttpService_connect_Params) error) (HttpService_connect_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0x92963bfdad2beb6a,
			MethodID:      2,
			InterfaceName: "http-over-capnp.capnp:HttpService",
			MethodName:    "connect",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 5}
		s.PlaceArgs = func(s capnp.Struct) error { return params(HttpService_connect_Params(s)) }
	}

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

}

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

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

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

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

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

// A HttpService_Server is a HttpService with a local implementation.
type HttpService_Server interface {
	StartRequest(context.Context, HttpService_startRequest) error

	Request(context.Context, HttpService_request) error

	Connect(context.Context, HttpService_connect) error
}

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

// HttpService_ServerToClient creates a new Client from an implementation of HttpService_Server.
// The caller is responsible for calling Release on the returned Client.
func HttpService_ServerToClient(s HttpService_Server) HttpService {
	return HttpService(capnp.NewClient(HttpService_NewServer(s)))
}

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

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0x92963bfdad2beb6a,
			MethodID:      0,
			InterfaceName: "http-over-capnp.capnp:HttpService",
			MethodName:    "startRequest",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.StartRequest(ctx, HttpService_startRequest{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0x92963bfdad2beb6a,
			MethodID:      1,
			InterfaceName: "http-over-capnp.capnp:HttpService",
			MethodName:    "request",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.Request(ctx, HttpService_request{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0x92963bfdad2beb6a,
			MethodID:      2,
			InterfaceName: "http-over-capnp.capnp:HttpService",
			MethodName:    "connect",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.Connect(ctx, HttpService_connect{call})
		},
	})

	return methods
}

// HttpService_startRequest holds the state for a server call to HttpService.startRequest.
// See server.Call for documentation.
type HttpService_startRequest struct {
	*server.Call
}

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

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

// HttpService_request holds the state for a server call to HttpService.request.
// See server.Call for documentation.
type HttpService_request struct {
	*server.Call
}

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

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

// HttpService_connect holds the state for a server call to HttpService.connect.
// See server.Call for documentation.
type HttpService_connect struct {
	*server.Call
}

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

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

// HttpService_List is a list of HttpService.
type HttpService_List = capnp.CapList[HttpService]

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

type HttpService_ClientRequestContext capnp.Client

// HttpService_ClientRequestContext_TypeID is the unique identifier for the type HttpService_ClientRequestContext.
const HttpService_ClientRequestContext_TypeID = 0xea3256705c0b63ba

func (c HttpService_ClientRequestContext) StartResponse(ctx context.Context, params func(HttpService_ClientRequestContext_startResponse_Params) error) (HttpService_ClientRequestContext_startResponse_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xea3256705c0b63ba,
			MethodID:      0,
			InterfaceName: "http-over-capnp.capnp:HttpService.ClientRequestContext",
			MethodName:    "startResponse",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(HttpService_ClientRequestContext_startResponse_Params(s)) }
	}

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

}

func (c HttpService_ClientRequestContext) StartWebSocket(ctx context.Context, params func(HttpService_ClientRequestContext_startWebSocket_Params) error) (HttpService_ClientRequestContext_startWebSocket_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xea3256705c0b63ba,
			MethodID:      1,
			InterfaceName: "http-over-capnp.capnp:HttpService.ClientRequestContext",
			MethodName:    "startWebSocket",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 2}
		s.PlaceArgs = func(s capnp.Struct) error { return params(HttpService_ClientRequestContext_startWebSocket_Params(s)) }
	}

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

}

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

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

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

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

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

// A HttpService_ClientRequestContext_Server is a HttpService_ClientRequestContext with a local implementation.
type HttpService_ClientRequestContext_Server interface {
	StartResponse(context.Context, HttpService_ClientRequestContext_startResponse) error

	StartWebSocket(context.Context, HttpService_ClientRequestContext_startWebSocket) error
}

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

// HttpService_ClientRequestContext_ServerToClient creates a new Client from an implementation of HttpService_ClientRequestContext_Server.
// The caller is responsible for calling Release on the returned Client.
func HttpService_ClientRequestContext_ServerToClient(s HttpService_ClientRequestContext_Server) HttpService_ClientRequestContext {
	return HttpService_ClientRequestContext(capnp.NewClient(HttpService_ClientRequestContext_NewServer(s)))
}

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

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xea3256705c0b63ba,
			MethodID:      0,
			InterfaceName: "http-over-capnp.capnp:HttpService.ClientRequestContext",
			MethodName:    "startResponse",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.StartResponse(ctx, HttpService_ClientRequestContext_startResponse{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xea3256705c0b63ba,
			MethodID:      1,
			InterfaceName: "http-over-capnp.capnp:HttpService.ClientRequestContext",
			MethodName:    "startWebSocket",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.StartWebSocket(ctx, HttpService_ClientRequestContext_startWebSocket{call})
		},
	})

	return methods
}

// HttpService_ClientRequestContext_startResponse holds the state for a server call to HttpService_ClientRequestContext.startResponse.
// See server.Call for documentation.
type HttpService_ClientRequestContext_startResponse struct {
	*server.Call
}

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

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

// HttpService_ClientRequestContext_startWebSocket holds the state for a server call to HttpService_ClientRequestContext.startWebSocket.
// See server.Call for documentation.
type HttpService_ClientRequestContext_startWebSocket struct {
	*server.Call
}

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

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

// HttpService_ClientRequestContext_List is a list of HttpService_ClientRequestContext.
type HttpService_ClientRequestContext_List = capnp.CapList[HttpService_ClientRequestContext]

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

type HttpService_ClientRequestContext_startResponse_Params capnp.Struct

// HttpService_ClientRequestContext_startResponse_Params_TypeID is the unique identifier for the type HttpService_ClientRequestContext_startResponse_Params.
const HttpService_ClientRequestContext_startResponse_Params_TypeID = 0x81e666258a901e30

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

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

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

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

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

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

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

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

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

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

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

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

// HttpService_ClientRequestContext_startResponse_Params_List is a list of HttpService_ClientRequestContext_startResponse_Params.
type HttpService_ClientRequestContext_startResponse_Params_List = capnp.StructList[HttpService_ClientRequestContext_startResponse_Params]

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

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

func (f HttpService_ClientRequestContext_startResponse_Params_Future) Struct() (HttpService_ClientRequestContext_startResponse_Params, error) {
	p, err := f.Future.Ptr()
	return HttpService_ClientRequestContext_startResponse_Params(p.Struct()), err
}
func (p HttpService_ClientRequestContext_startResponse_Params_Future) Response() HttpResponse_Future {
	return HttpResponse_Future{Future: p.Future.Field(0, nil)}
}

type HttpService_ClientRequestContext_startResponse_Results capnp.Struct

// HttpService_ClientRequestContext_startResponse_Results_TypeID is the unique identifier for the type HttpService_ClientRequestContext_startResponse_Results.
const HttpService_ClientRequestContext_startResponse_Results_TypeID = 0x955c85d7a557d8e9

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

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

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

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

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

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

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

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

func (s HttpService_ClientRequestContext_startResponse_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpService_ClientRequestContext_startResponse_Results) Body() bytestream.ByteStream {
	p, _ := capnp.Struct(s).Ptr(0)
	return bytestream.ByteStream(p.Interface().Client())
}

func (s HttpService_ClientRequestContext_startResponse_Results) HasBody() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

// HttpService_ClientRequestContext_startResponse_Results_List is a list of HttpService_ClientRequestContext_startResponse_Results.
type HttpService_ClientRequestContext_startResponse_Results_List = capnp.StructList[HttpService_ClientRequestContext_startResponse_Results]

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

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

func (f HttpService_ClientRequestContext_startResponse_Results_Future) Struct() (HttpService_ClientRequestContext_startResponse_Results, error) {
	p, err := f.Future.Ptr()
	return HttpService_ClientRequestContext_startResponse_Results(p.Struct()), err
}
func (p HttpService_ClientRequestContext_startResponse_Results_Future) Body() bytestream.ByteStream {
	return bytestream.ByteStream(p.Future.Field(0, nil).Client())
}

type HttpService_ClientRequestContext_startWebSocket_Params capnp.Struct

// HttpService_ClientRequestContext_startWebSocket_Params_TypeID is the unique identifier for the type HttpService_ClientRequestContext_startWebSocket_Params.
const HttpService_ClientRequestContext_startWebSocket_Params_TypeID = 0xf6850b405e21d2c1

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

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

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

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

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

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

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

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

func (s HttpService_ClientRequestContext_startWebSocket_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpService_ClientRequestContext_startWebSocket_Params) Headers() (HttpHeader_List, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return HttpHeader_List(p.List()), err
}

func (s HttpService_ClientRequestContext_startWebSocket_Params) HasHeaders() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s HttpService_ClientRequestContext_startWebSocket_Params) SetHeaders(v HttpHeader_List) error {
	return capnp.Struct(s).SetPtr(0, v.ToPtr())
}

// NewHeaders sets the headers field to a newly
// allocated HttpHeader_List, preferring placement in s's segment.
func (s HttpService_ClientRequestContext_startWebSocket_Params) NewHeaders(n int32) (HttpHeader_List, error) {
	l, err := NewHttpHeader_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return HttpHeader_List{}, err
	}
	err = capnp.Struct(s).SetPtr(0, l.ToPtr())
	return l, err
}
func (s HttpService_ClientRequestContext_startWebSocket_Params) UpSocket() WebSocket {
	p, _ := capnp.Struct(s).Ptr(1)
	return WebSocket(p.Interface().Client())
}

func (s HttpService_ClientRequestContext_startWebSocket_Params) HasUpSocket() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s HttpService_ClientRequestContext_startWebSocket_Params) SetUpSocket(v WebSocket) error {
	if !v.IsValid() {
		return capnp.Struct(s).SetPtr(1, capnp.Ptr{})
	}
	seg := s.Segment()
	in := capnp.NewInterface(seg, seg.Message().CapTable().Add(capnp.Client(v)))
	return capnp.Struct(s).SetPtr(1, in.ToPtr())
}

// HttpService_ClientRequestContext_startWebSocket_Params_List is a list of HttpService_ClientRequestContext_startWebSocket_Params.
type HttpService_ClientRequestContext_startWebSocket_Params_List = capnp.StructList[HttpService_ClientRequestContext_startWebSocket_Params]

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

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

func (f HttpService_ClientRequestContext_startWebSocket_Params_Future) Struct() (HttpService_ClientRequestContext_startWebSocket_Params, error) {
	p, err := f.Future.Ptr()
	return HttpService_ClientRequestContext_startWebSocket_Params(p.Struct()), err
}
func (p HttpService_ClientRequestContext_startWebSocket_Params_Future) UpSocket() WebSocket {
	return WebSocket(p.Future.Field(1, nil).Client())
}

type HttpService_ClientRequestContext_startWebSocket_Results capnp.Struct

// HttpService_ClientRequestContext_startWebSocket_Results_TypeID is the unique identifier for the type HttpService_ClientRequestContext_startWebSocket_Results.
const HttpService_ClientRequestContext_startWebSocket_Results_TypeID = 0xbd146efdadd86c3d

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

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

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

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

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

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

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

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

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

func (s HttpService_ClientRequestContext_startWebSocket_Results) HasDownSocket() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

// HttpService_ClientRequestContext_startWebSocket_Results_List is a list of HttpService_ClientRequestContext_startWebSocket_Results.
type HttpService_ClientRequestContext_startWebSocket_Results_List = capnp.StructList[HttpService_ClientRequestContext_startWebSocket_Results]

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

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

func (f HttpService_ClientRequestContext_startWebSocket_Results_Future) Struct() (HttpService_ClientRequestContext_startWebSocket_Results, error) {
	p, err := f.Future.Ptr()
	return HttpService_ClientRequestContext_startWebSocket_Results(p.Struct()), err
}
func (p HttpService_ClientRequestContext_startWebSocket_Results_Future) DownSocket() WebSocket {
	return WebSocket(p.Future.Field(0, nil).Client())
}

type HttpService_ConnectClientRequestContext capnp.Client

// HttpService_ConnectClientRequestContext_TypeID is the unique identifier for the type HttpService_ConnectClientRequestContext.
const HttpService_ConnectClientRequestContext_TypeID = 0xda572939a4c3d728

func (c HttpService_ConnectClientRequestContext) StartConnect(ctx context.Context, params func(HttpService_ConnectClientRequestContext_startConnect_Params) error) (HttpService_ConnectClientRequestContext_startConnect_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xda572939a4c3d728,
			MethodID:      0,
			InterfaceName: "http-over-capnp.capnp:HttpService.ConnectClientRequestContext",
			MethodName:    "startConnect",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error {
			return params(HttpService_ConnectClientRequestContext_startConnect_Params(s))
		}
	}

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

}

func (c HttpService_ConnectClientRequestContext) StartError(ctx context.Context, params func(HttpService_ConnectClientRequestContext_startError_Params) error) (HttpService_ConnectClientRequestContext_startError_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xda572939a4c3d728,
			MethodID:      1,
			InterfaceName: "http-over-capnp.capnp:HttpService.ConnectClientRequestContext",
			MethodName:    "startError",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error {
			return params(HttpService_ConnectClientRequestContext_startError_Params(s))
		}
	}

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

}

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

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

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

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

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

// A HttpService_ConnectClientRequestContext_Server is a HttpService_ConnectClientRequestContext with a local implementation.
type HttpService_ConnectClientRequestContext_Server interface {
	StartConnect(context.Context, HttpService_ConnectClientRequestContext_startConnect) error

	StartError(context.Context, HttpService_ConnectClientRequestContext_startError) error
}

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

// HttpService_ConnectClientRequestContext_ServerToClient creates a new Client from an implementation of HttpService_ConnectClientRequestContext_Server.
// The caller is responsible for calling Release on the returned Client.
func HttpService_ConnectClientRequestContext_ServerToClient(s HttpService_ConnectClientRequestContext_Server) HttpService_ConnectClientRequestContext {
	return HttpService_ConnectClientRequestContext(capnp.NewClient(HttpService_ConnectClientRequestContext_NewServer(s)))
}

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

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xda572939a4c3d728,
			MethodID:      0,
			InterfaceName: "http-over-capnp.capnp:HttpService.ConnectClientRequestContext",
			MethodName:    "startConnect",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.StartConnect(ctx, HttpService_ConnectClientRequestContext_startConnect{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xda572939a4c3d728,
			MethodID:      1,
			InterfaceName: "http-over-capnp.capnp:HttpService.ConnectClientRequestContext",
			MethodName:    "startError",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.StartError(ctx, HttpService_ConnectClientRequestContext_startError{call})
		},
	})

	return methods
}

// HttpService_ConnectClientRequestContext_startConnect holds the state for a server call to HttpService_ConnectClientRequestContext.startConnect.
// See server.Call for documentation.
type HttpService_ConnectClientRequestContext_startConnect struct {
	*server.Call
}

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

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

// HttpService_ConnectClientRequestContext_startError holds the state for a server call to HttpService_ConnectClientRequestContext.startError.
// See server.Call for documentation.
type HttpService_ConnectClientRequestContext_startError struct {
	*server.Call
}

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

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

// HttpService_ConnectClientRequestContext_List is a list of HttpService_ConnectClientRequestContext.
type HttpService_ConnectClientRequestContext_List = capnp.CapList[HttpService_ConnectClientRequestContext]

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

type HttpService_ConnectClientRequestContext_startConnect_Params capnp.Struct

// HttpService_ConnectClientRequestContext_startConnect_Params_TypeID is the unique identifier for the type HttpService_ConnectClientRequestContext_startConnect_Params.
const HttpService_ConnectClientRequestContext_startConnect_Params_TypeID = 0xd0eab1ea093a6673

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

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

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

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

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

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

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

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

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

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

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

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

// HttpService_ConnectClientRequestContext_startConnect_Params_List is a list of HttpService_ConnectClientRequestContext_startConnect_Params.
type HttpService_ConnectClientRequestContext_startConnect_Params_List = capnp.StructList[HttpService_ConnectClientRequestContext_startConnect_Params]

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

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

func (f HttpService_ConnectClientRequestContext_startConnect_Params_Future) Struct() (HttpService_ConnectClientRequestContext_startConnect_Params, error) {
	p, err := f.Future.Ptr()
	return HttpService_ConnectClientRequestContext_startConnect_Params(p.Struct()), err
}
func (p HttpService_ConnectClientRequestContext_startConnect_Params_Future) Response() HttpResponse_Future {
	return HttpResponse_Future{Future: p.Future.Field(0, nil)}
}

type HttpService_ConnectClientRequestContext_startConnect_Results capnp.Struct

// HttpService_ConnectClientRequestContext_startConnect_Results_TypeID is the unique identifier for the type HttpService_ConnectClientRequestContext_startConnect_Results.
const HttpService_ConnectClientRequestContext_startConnect_Results_TypeID = 0xfa73959a9a2b477d

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

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

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

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

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

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

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

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

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

// HttpService_ConnectClientRequestContext_startConnect_Results_List is a list of HttpService_ConnectClientRequestContext_startConnect_Results.
type HttpService_ConnectClientRequestContext_startConnect_Results_List = capnp.StructList[HttpService_ConnectClientRequestContext_startConnect_Results]

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

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

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

type HttpService_ConnectClientRequestContext_startError_Params capnp.Struct

// HttpService_ConnectClientRequestContext_startError_Params_TypeID is the unique identifier for the type HttpService_ConnectClientRequestContext_startError_Params.
const HttpService_ConnectClientRequestContext_startError_Params_TypeID = 0xfe0ea4cde5df8164

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

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

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

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

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

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

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

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

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

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

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

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

// HttpService_ConnectClientRequestContext_startError_Params_List is a list of HttpService_ConnectClientRequestContext_startError_Params.
type HttpService_ConnectClientRequestContext_startError_Params_List = capnp.StructList[HttpService_ConnectClientRequestContext_startError_Params]

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

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

func (f HttpService_ConnectClientRequestContext_startError_Params_Future) Struct() (HttpService_ConnectClientRequestContext_startError_Params, error) {
	p, err := f.Future.Ptr()
	return HttpService_ConnectClientRequestContext_startError_Params(p.Struct()), err
}
func (p HttpService_ConnectClientRequestContext_startError_Params_Future) Response() HttpResponse_Future {
	return HttpResponse_Future{Future: p.Future.Field(0, nil)}
}

type HttpService_ConnectClientRequestContext_startError_Results capnp.Struct

// HttpService_ConnectClientRequestContext_startError_Results_TypeID is the unique identifier for the type HttpService_ConnectClientRequestContext_startError_Results.
const HttpService_ConnectClientRequestContext_startError_Results_TypeID = 0xb92efa728643f0ed

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

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

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

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

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

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

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

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

func (s HttpService_ConnectClientRequestContext_startError_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpService_ConnectClientRequestContext_startError_Results) Body() bytestream.ByteStream {
	p, _ := capnp.Struct(s).Ptr(0)
	return bytestream.ByteStream(p.Interface().Client())
}

func (s HttpService_ConnectClientRequestContext_startError_Results) HasBody() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

// HttpService_ConnectClientRequestContext_startError_Results_List is a list of HttpService_ConnectClientRequestContext_startError_Results.
type HttpService_ConnectClientRequestContext_startError_Results_List = capnp.StructList[HttpService_ConnectClientRequestContext_startError_Results]

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

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

func (f HttpService_ConnectClientRequestContext_startError_Results_Future) Struct() (HttpService_ConnectClientRequestContext_startError_Results, error) {
	p, err := f.Future.Ptr()
	return HttpService_ConnectClientRequestContext_startError_Results(p.Struct()), err
}
func (p HttpService_ConnectClientRequestContext_startError_Results_Future) Body() bytestream.ByteStream {
	return bytestream.ByteStream(p.Future.Field(0, nil).Client())
}

type HttpService_ServerRequestContext capnp.Client

// HttpService_ServerRequestContext_TypeID is the unique identifier for the type HttpService_ServerRequestContext.
const HttpService_ServerRequestContext_TypeID = 0x99ae26bfd34f3f3b

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

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

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

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

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

// A HttpService_ServerRequestContext_Server is a HttpService_ServerRequestContext with a local implementation.
type HttpService_ServerRequestContext_Server interface {
}

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

// HttpService_ServerRequestContext_ServerToClient creates a new Client from an implementation of HttpService_ServerRequestContext_Server.
// The caller is responsible for calling Release on the returned Client.
func HttpService_ServerRequestContext_ServerToClient(s HttpService_ServerRequestContext_Server) HttpService_ServerRequestContext {
	return HttpService_ServerRequestContext(capnp.NewClient(HttpService_ServerRequestContext_NewServer(s)))
}

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

	return methods
}

// HttpService_ServerRequestContext_List is a list of HttpService_ServerRequestContext.
type HttpService_ServerRequestContext_List = capnp.CapList[HttpService_ServerRequestContext]

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

type HttpService_startRequest_Params capnp.Struct

// HttpService_startRequest_Params_TypeID is the unique identifier for the type HttpService_startRequest_Params.
const HttpService_startRequest_Params_TypeID = 0xccefbf23794af7b3

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

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

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

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

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

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

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

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

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

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

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

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

func (s HttpService_startRequest_Params) Context() HttpService_ClientRequestContext {
	p, _ := capnp.Struct(s).Ptr(1)
	return HttpService_ClientRequestContext(p.Interface().Client())
}

func (s HttpService_startRequest_Params) HasContext() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s HttpService_startRequest_Params) SetContext(v HttpService_ClientRequestContext) error {
	if !v.IsValid() {
		return capnp.Struct(s).SetPtr(1, capnp.Ptr{})
	}
	seg := s.Segment()
	in := capnp.NewInterface(seg, seg.Message().CapTable().Add(capnp.Client(v)))
	return capnp.Struct(s).SetPtr(1, in.ToPtr())
}

// HttpService_startRequest_Params_List is a list of HttpService_startRequest_Params.
type HttpService_startRequest_Params_List = capnp.StructList[HttpService_startRequest_Params]

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

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

func (f HttpService_startRequest_Params_Future) Struct() (HttpService_startRequest_Params, error) {
	p, err := f.Future.Ptr()
	return HttpService_startRequest_Params(p.Struct()), err
}
func (p HttpService_startRequest_Params_Future) Request() HttpRequest_Future {
	return HttpRequest_Future{Future: p.Future.Field(0, nil)}
}
func (p HttpService_startRequest_Params_Future) Context() HttpService_ClientRequestContext {
	return HttpService_ClientRequestContext(p.Future.Field(1, nil).Client())
}

type HttpService_startRequest_Results capnp.Struct

// HttpService_startRequest_Results_TypeID is the unique identifier for the type HttpService_startRequest_Results.
const HttpService_startRequest_Results_TypeID = 0xa9da072c30fec5de

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

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

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

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

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

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

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

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

func (s HttpService_startRequest_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpService_startRequest_Results) RequestBody() bytestream.ByteStream {
	p, _ := capnp.Struct(s).Ptr(0)
	return bytestream.ByteStream(p.Interface().Client())
}

func (s HttpService_startRequest_Results) HasRequestBody() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

func (s HttpService_startRequest_Results) Context() HttpService_ServerRequestContext {
	p, _ := capnp.Struct(s).Ptr(1)
	return HttpService_ServerRequestContext(p.Interface().Client())
}

func (s HttpService_startRequest_Results) HasContext() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s HttpService_startRequest_Results) SetContext(v HttpService_ServerRequestContext) error {
	if !v.IsValid() {
		return capnp.Struct(s).SetPtr(1, capnp.Ptr{})
	}
	seg := s.Segment()
	in := capnp.NewInterface(seg, seg.Message().CapTable().Add(capnp.Client(v)))
	return capnp.Struct(s).SetPtr(1, in.ToPtr())
}

// HttpService_startRequest_Results_List is a list of HttpService_startRequest_Results.
type HttpService_startRequest_Results_List = capnp.StructList[HttpService_startRequest_Results]

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

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

func (f HttpService_startRequest_Results_Future) Struct() (HttpService_startRequest_Results, error) {
	p, err := f.Future.Ptr()
	return HttpService_startRequest_Results(p.Struct()), err
}
func (p HttpService_startRequest_Results_Future) RequestBody() bytestream.ByteStream {
	return bytestream.ByteStream(p.Future.Field(0, nil).Client())
}

func (p HttpService_startRequest_Results_Future) Context() HttpService_ServerRequestContext {
	return HttpService_ServerRequestContext(p.Future.Field(1, nil).Client())
}

type HttpService_request_Params capnp.Struct

// HttpService_request_Params_TypeID is the unique identifier for the type HttpService_request_Params.
const HttpService_request_Params_TypeID = 0xccc73319af8d2a1b

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

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

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

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

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

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

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

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

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

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

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

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

func (s HttpService_request_Params) Context() HttpService_ClientRequestContext {
	p, _ := capnp.Struct(s).Ptr(1)
	return HttpService_ClientRequestContext(p.Interface().Client())
}

func (s HttpService_request_Params) HasContext() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s HttpService_request_Params) SetContext(v HttpService_ClientRequestContext) error {
	if !v.IsValid() {
		return capnp.Struct(s).SetPtr(1, capnp.Ptr{})
	}
	seg := s.Segment()
	in := capnp.NewInterface(seg, seg.Message().CapTable().Add(capnp.Client(v)))
	return capnp.Struct(s).SetPtr(1, in.ToPtr())
}

// HttpService_request_Params_List is a list of HttpService_request_Params.
type HttpService_request_Params_List = capnp.StructList[HttpService_request_Params]

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

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

func (f HttpService_request_Params_Future) Struct() (HttpService_request_Params, error) {
	p, err := f.Future.Ptr()
	return HttpService_request_Params(p.Struct()), err
}
func (p HttpService_request_Params_Future) Request() HttpRequest_Future {
	return HttpRequest_Future{Future: p.Future.Field(0, nil)}
}
func (p HttpService_request_Params_Future) Context() HttpService_ClientRequestContext {
	return HttpService_ClientRequestContext(p.Future.Field(1, nil).Client())
}

type HttpService_request_Results capnp.Struct

// HttpService_request_Results_TypeID is the unique identifier for the type HttpService_request_Results.
const HttpService_request_Results_TypeID = 0xfd030bd777152c43

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

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

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

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

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

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

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

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

func (s HttpService_request_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpService_request_Results) RequestBody() bytestream.ByteStream {
	p, _ := capnp.Struct(s).Ptr(0)
	return bytestream.ByteStream(p.Interface().Client())
}

func (s HttpService_request_Results) HasRequestBody() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

// HttpService_request_Results_List is a list of HttpService_request_Results.
type HttpService_request_Results_List = capnp.StructList[HttpService_request_Results]

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

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

func (f HttpService_request_Results_Future) Struct() (HttpService_request_Results, error) {
	p, err := f.Future.Ptr()
	return HttpService_request_Results(p.Struct()), err
}
func (p HttpService_request_Results_Future) RequestBody() bytestream.ByteStream {
	return bytestream.ByteStream(p.Future.Field(0, nil).Client())
}

type HttpService_connect_Params capnp.Struct

// HttpService_connect_Params_TypeID is the unique identifier for the type HttpService_connect_Params.
const HttpService_connect_Params_TypeID = 0xa8d63d909cead201

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

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

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

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

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

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

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

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

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

func (s HttpService_connect_Params) HasHost() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

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

func (s HttpService_connect_Params) Headers() (HttpHeader_List, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return HttpHeader_List(p.List()), err
}

func (s HttpService_connect_Params) HasHeaders() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s HttpService_connect_Params) SetHeaders(v HttpHeader_List) error {
	return capnp.Struct(s).SetPtr(1, v.ToPtr())
}

// NewHeaders sets the headers field to a newly
// allocated HttpHeader_List, preferring placement in s's segment.
func (s HttpService_connect_Params) NewHeaders(n int32) (HttpHeader_List, error) {
	l, err := NewHttpHeader_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return HttpHeader_List{}, err
	}
	err = capnp.Struct(s).SetPtr(1, l.ToPtr())
	return l, err
}
func (s HttpService_connect_Params) Down() bytestream.ByteStream {
	p, _ := capnp.Struct(s).Ptr(2)
	return bytestream.ByteStream(p.Interface().Client())
}

func (s HttpService_connect_Params) HasDown() bool {
	return capnp.Struct(s).HasPtr(2)
}

func (s HttpService_connect_Params) SetDown(v bytestream.ByteStream) error {
	if !v.IsValid() {
		return capnp.Struct(s).SetPtr(2, capnp.Ptr{})
	}
	seg := s.Segment()
	in := capnp.NewInterface(seg, seg.Message().CapTable().Add(capnp.Client(v)))
	return capnp.Struct(s).SetPtr(2, in.ToPtr())
}

func (s HttpService_connect_Params) Context() HttpService_ConnectClientRequestContext {
	p, _ := capnp.Struct(s).Ptr(3)
	return HttpService_ConnectClientRequestContext(p.Interface().Client())
}

func (s HttpService_connect_Params) HasContext() bool {
	return capnp.Struct(s).HasPtr(3)
}

func (s HttpService_connect_Params) SetContext(v HttpService_ConnectClientRequestContext) error {
	if !v.IsValid() {
		return capnp.Struct(s).SetPtr(3, capnp.Ptr{})
	}
	seg := s.Segment()
	in := capnp.NewInterface(seg, seg.Message().CapTable().Add(capnp.Client(v)))
	return capnp.Struct(s).SetPtr(3, in.ToPtr())
}

func (s HttpService_connect_Params) Settings() (ConnectSettings, error) {
	p, err := capnp.Struct(s).Ptr(4)
	return ConnectSettings(p.Struct()), err
}

func (s HttpService_connect_Params) HasSettings() bool {
	return capnp.Struct(s).HasPtr(4)
}

func (s HttpService_connect_Params) SetSettings(v ConnectSettings) error {
	return capnp.Struct(s).SetPtr(4, capnp.Struct(v).ToPtr())
}

// NewSettings sets the settings field to a newly
// allocated ConnectSettings struct, preferring placement in s's segment.
func (s HttpService_connect_Params) NewSettings() (ConnectSettings, error) {
	ss, err := NewConnectSettings(capnp.Struct(s).Segment())
	if err != nil {
		return ConnectSettings{}, err
	}
	err = capnp.Struct(s).SetPtr(4, capnp.Struct(ss).ToPtr())
	return ss, err
}

// HttpService_connect_Params_List is a list of HttpService_connect_Params.
type HttpService_connect_Params_List = capnp.StructList[HttpService_connect_Params]

// NewHttpService_connect_Params creates a new list of HttpService_connect_Params.
func NewHttpService_connect_Params_List(s *capnp.Segment, sz int32) (HttpService_connect_Params_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 5}, sz)
	return capnp.StructList[HttpService_connect_Params](l), err
}

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

func (f HttpService_connect_Params_Future) Struct() (HttpService_connect_Params, error) {
	p, err := f.Future.Ptr()
	return HttpService_connect_Params(p.Struct()), err
}
func (p HttpService_connect_Params_Future) Down() bytestream.ByteStream {
	return bytestream.ByteStream(p.Future.Field(2, nil).Client())
}

func (p HttpService_connect_Params_Future) Context() HttpService_ConnectClientRequestContext {
	return HttpService_ConnectClientRequestContext(p.Future.Field(3, nil).Client())
}

func (p HttpService_connect_Params_Future) Settings() ConnectSettings_Future {
	return ConnectSettings_Future{Future: p.Future.Field(4, nil)}
}

type HttpService_connect_Results capnp.Struct

// HttpService_connect_Results_TypeID is the unique identifier for the type HttpService_connect_Results.
const HttpService_connect_Results_TypeID = 0xbf2721059c3d9248

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

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

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

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

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

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

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

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

func (s HttpService_connect_Results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpService_connect_Results) Up() bytestream.ByteStream {
	p, _ := capnp.Struct(s).Ptr(0)
	return bytestream.ByteStream(p.Interface().Client())
}

func (s HttpService_connect_Results) HasUp() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

// HttpService_connect_Results_List is a list of HttpService_connect_Results.
type HttpService_connect_Results_List = capnp.StructList[HttpService_connect_Results]

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

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

func (f HttpService_connect_Results_Future) Struct() (HttpService_connect_Results, error) {
	p, err := f.Future.Ptr()
	return HttpService_connect_Results(p.Struct()), err
}
func (p HttpService_connect_Results_Future) Up() bytestream.ByteStream {
	return bytestream.ByteStream(p.Future.Field(0, nil).Client())
}

type ConnectSettings capnp.Struct

// ConnectSettings_TypeID is the unique identifier for the type ConnectSettings.
const ConnectSettings_TypeID = 0xf981e8428b86f885

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

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

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

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

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

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

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

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

func (s ConnectSettings) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s ConnectSettings) UseTls() bool {
	return capnp.Struct(s).Bit(0)
}

func (s ConnectSettings) SetUseTls(v bool) {
	capnp.Struct(s).SetBit(0, v)
}

// ConnectSettings_List is a list of ConnectSettings.
type ConnectSettings_List = capnp.StructList[ConnectSettings]

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

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

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

type WebSocket capnp.Client

// WebSocket_TypeID is the unique identifier for the type WebSocket.
const WebSocket_TypeID = 0xb09c33a9f4caa823

func (c WebSocket) SendText(ctx context.Context, params func(WebSocket_sendText_Params) error) error {
	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb09c33a9f4caa823,
			MethodID:      0,
			InterfaceName: "http-over-capnp.capnp:WebSocket",
			MethodName:    "sendText",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(WebSocket_sendText_Params(s)) }
	}

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

}

func (c WebSocket) SendData(ctx context.Context, params func(WebSocket_sendData_Params) error) error {
	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb09c33a9f4caa823,
			MethodID:      1,
			InterfaceName: "http-over-capnp.capnp:WebSocket",
			MethodName:    "sendData",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(WebSocket_sendData_Params(s)) }
	}

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

}

func (c WebSocket) Close(ctx context.Context, params func(WebSocket_close_Params) error) (WebSocket_close_Results_Future, capnp.ReleaseFunc) {

	s := capnp.Send{
		Method: capnp.Method{
			InterfaceID:   0xb09c33a9f4caa823,
			MethodID:      2,
			InterfaceName: "http-over-capnp.capnp:WebSocket",
			MethodName:    "close",
		},
	}
	if params != nil {
		s.ArgsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 1}
		s.PlaceArgs = func(s capnp.Struct) error { return params(WebSocket_close_Params(s)) }
	}

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

}

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

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

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

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

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

// A WebSocket_Server is a WebSocket with a local implementation.
type WebSocket_Server interface {
	SendText(context.Context, WebSocket_sendText) error

	SendData(context.Context, WebSocket_sendData) error

	Close(context.Context, WebSocket_close) error
}

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

// WebSocket_ServerToClient creates a new Client from an implementation of WebSocket_Server.
// The caller is responsible for calling Release on the returned Client.
func WebSocket_ServerToClient(s WebSocket_Server) WebSocket {
	return WebSocket(capnp.NewClient(WebSocket_NewServer(s)))
}

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

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb09c33a9f4caa823,
			MethodID:      0,
			InterfaceName: "http-over-capnp.capnp:WebSocket",
			MethodName:    "sendText",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.SendText(ctx, WebSocket_sendText{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb09c33a9f4caa823,
			MethodID:      1,
			InterfaceName: "http-over-capnp.capnp:WebSocket",
			MethodName:    "sendData",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.SendData(ctx, WebSocket_sendData{call})
		},
	})

	methods = append(methods, server.Method{
		Method: capnp.Method{
			InterfaceID:   0xb09c33a9f4caa823,
			MethodID:      2,
			InterfaceName: "http-over-capnp.capnp:WebSocket",
			MethodName:    "close",
		},
		Impl: func(ctx context.Context, call *server.Call) error {
			return s.Close(ctx, WebSocket_close{call})
		},
	})

	return methods
}

// WebSocket_sendText holds the state for a server call to WebSocket.sendText.
// See server.Call for documentation.
type WebSocket_sendText struct {
	*server.Call
}

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

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

// WebSocket_sendData holds the state for a server call to WebSocket.sendData.
// See server.Call for documentation.
type WebSocket_sendData struct {
	*server.Call
}

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

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

// WebSocket_close holds the state for a server call to WebSocket.close.
// See server.Call for documentation.
type WebSocket_close struct {
	*server.Call
}

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

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

// WebSocket_List is a list of WebSocket.
type WebSocket_List = capnp.CapList[WebSocket]

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

type WebSocket_sendText_Params capnp.Struct

// WebSocket_sendText_Params_TypeID is the unique identifier for the type WebSocket_sendText_Params.
const WebSocket_sendText_Params_TypeID = 0xdcf946892e5778c3

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

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

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

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

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

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

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

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

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

func (s WebSocket_sendText_Params) HasText() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

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

// WebSocket_sendText_Params_List is a list of WebSocket_sendText_Params.
type WebSocket_sendText_Params_List = capnp.StructList[WebSocket_sendText_Params]

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

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

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

type WebSocket_sendData_Params capnp.Struct

// WebSocket_sendData_Params_TypeID is the unique identifier for the type WebSocket_sendData_Params.
const WebSocket_sendData_Params_TypeID = 0xa9b84fb6432f030f

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

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

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

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

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

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

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

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

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

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

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

// WebSocket_sendData_Params_List is a list of WebSocket_sendData_Params.
type WebSocket_sendData_Params_List = capnp.StructList[WebSocket_sendData_Params]

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

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

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

type WebSocket_close_Params capnp.Struct

// WebSocket_close_Params_TypeID is the unique identifier for the type WebSocket_close_Params.
const WebSocket_close_Params_TypeID = 0xba1fca454f465e9a

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

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

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

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

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

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

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

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

func (s WebSocket_close_Params) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s WebSocket_close_Params) Code() uint16 {
	return capnp.Struct(s).Uint16(0)
}

func (s WebSocket_close_Params) SetCode(v uint16) {
	capnp.Struct(s).SetUint16(0, v)
}

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

func (s WebSocket_close_Params) HasReason() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

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

// WebSocket_close_Params_List is a list of WebSocket_close_Params.
type WebSocket_close_Params_List = capnp.StructList[WebSocket_close_Params]

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

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

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

type WebSocket_close_Results capnp.Struct

// WebSocket_close_Results_TypeID is the unique identifier for the type WebSocket_close_Results.
const WebSocket_close_Results_TypeID = 0x913fe85057da9522

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

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

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

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

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

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

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

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

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

// WebSocket_close_Results_List is a list of WebSocket_close_Results.
type WebSocket_close_Results_List = capnp.StructList[WebSocket_close_Results]

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

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

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

type HttpRequest capnp.Struct
type HttpRequest_bodySize HttpRequest
type HttpRequest_bodySize_Which uint16

const (
	HttpRequest_bodySize_Which_unknown HttpRequest_bodySize_Which = 0
	HttpRequest_bodySize_Which_fixed   HttpRequest_bodySize_Which = 1
)

func (w HttpRequest_bodySize_Which) String() string {
	const s = "unknownfixed"
	switch w {
	case HttpRequest_bodySize_Which_unknown:
		return s[0:7]
	case HttpRequest_bodySize_Which_fixed:
		return s[7:12]

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

// HttpRequest_TypeID is the unique identifier for the type HttpRequest.
const HttpRequest_TypeID = 0xdeb08db1052a4866

func NewHttpRequest(s *capnp.Segment) (HttpRequest, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 2})
	return HttpRequest(st), err
}

func NewRootHttpRequest(s *capnp.Segment) (HttpRequest, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 2})
	return HttpRequest(st), err
}

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

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

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

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

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

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

func (s HttpRequest) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpRequest) Method() HttpMethod {
	return HttpMethod(capnp.Struct(s).Uint16(0))
}

func (s HttpRequest) SetMethod(v HttpMethod) {
	capnp.Struct(s).SetUint16(0, uint16(v))
}

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

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

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

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

func (s HttpRequest) Headers() (HttpHeader_List, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return HttpHeader_List(p.List()), err
}

func (s HttpRequest) HasHeaders() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s HttpRequest) SetHeaders(v HttpHeader_List) error {
	return capnp.Struct(s).SetPtr(1, v.ToPtr())
}

// NewHeaders sets the headers field to a newly
// allocated HttpHeader_List, preferring placement in s's segment.
func (s HttpRequest) NewHeaders(n int32) (HttpHeader_List, error) {
	l, err := NewHttpHeader_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return HttpHeader_List{}, err
	}
	err = capnp.Struct(s).SetPtr(1, l.ToPtr())
	return l, err
}
func (s HttpRequest) BodySize() HttpRequest_bodySize { return HttpRequest_bodySize(s) }

func (s HttpRequest_bodySize) Which() HttpRequest_bodySize_Which {
	return HttpRequest_bodySize_Which(capnp.Struct(s).Uint16(2))
}
func (s HttpRequest_bodySize) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

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

func (s HttpRequest_bodySize) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpRequest_bodySize) SetUnknown() {
	capnp.Struct(s).SetUint16(2, 0)

}

func (s HttpRequest_bodySize) Fixed() uint64 {
	if capnp.Struct(s).Uint16(2) != 1 {
		panic("Which() != fixed")
	}
	return capnp.Struct(s).Uint64(8)
}

func (s HttpRequest_bodySize) SetFixed(v uint64) {
	capnp.Struct(s).SetUint16(2, 1)
	capnp.Struct(s).SetUint64(8, v)
}

// HttpRequest_List is a list of HttpRequest.
type HttpRequest_List = capnp.StructList[HttpRequest]

// NewHttpRequest creates a new list of HttpRequest.
func NewHttpRequest_List(s *capnp.Segment, sz int32) (HttpRequest_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 2}, sz)
	return capnp.StructList[HttpRequest](l), err
}

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

func (f HttpRequest_Future) Struct() (HttpRequest, error) {
	p, err := f.Future.Ptr()
	return HttpRequest(p.Struct()), err
}
func (p HttpRequest_Future) BodySize() HttpRequest_bodySize_Future {
	return HttpRequest_bodySize_Future{p.Future}
}

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

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

type HttpResponse capnp.Struct
type HttpResponse_bodySize HttpResponse
type HttpResponse_bodySize_Which uint16

const (
	HttpResponse_bodySize_Which_unknown HttpResponse_bodySize_Which = 0
	HttpResponse_bodySize_Which_fixed   HttpResponse_bodySize_Which = 1
)

func (w HttpResponse_bodySize_Which) String() string {
	const s = "unknownfixed"
	switch w {
	case HttpResponse_bodySize_Which_unknown:
		return s[0:7]
	case HttpResponse_bodySize_Which_fixed:
		return s[7:12]

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

// HttpResponse_TypeID is the unique identifier for the type HttpResponse.
const HttpResponse_TypeID = 0xf235351cf1531299

func NewHttpResponse(s *capnp.Segment) (HttpResponse, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 2})
	return HttpResponse(st), err
}

func NewRootHttpResponse(s *capnp.Segment) (HttpResponse, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 2})
	return HttpResponse(st), err
}

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

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

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

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

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

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

func (s HttpResponse) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpResponse) StatusCode() uint16 {
	return capnp.Struct(s).Uint16(0)
}

func (s HttpResponse) SetStatusCode(v uint16) {
	capnp.Struct(s).SetUint16(0, v)
}

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

func (s HttpResponse) HasStatusText() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

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

func (s HttpResponse) Headers() (HttpHeader_List, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return HttpHeader_List(p.List()), err
}

func (s HttpResponse) HasHeaders() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s HttpResponse) SetHeaders(v HttpHeader_List) error {
	return capnp.Struct(s).SetPtr(1, v.ToPtr())
}

// NewHeaders sets the headers field to a newly
// allocated HttpHeader_List, preferring placement in s's segment.
func (s HttpResponse) NewHeaders(n int32) (HttpHeader_List, error) {
	l, err := NewHttpHeader_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return HttpHeader_List{}, err
	}
	err = capnp.Struct(s).SetPtr(1, l.ToPtr())
	return l, err
}
func (s HttpResponse) BodySize() HttpResponse_bodySize { return HttpResponse_bodySize(s) }

func (s HttpResponse_bodySize) Which() HttpResponse_bodySize_Which {
	return HttpResponse_bodySize_Which(capnp.Struct(s).Uint16(2))
}
func (s HttpResponse_bodySize) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

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

func (s HttpResponse_bodySize) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpResponse_bodySize) SetUnknown() {
	capnp.Struct(s).SetUint16(2, 0)

}

func (s HttpResponse_bodySize) Fixed() uint64 {
	if capnp.Struct(s).Uint16(2) != 1 {
		panic("Which() != fixed")
	}
	return capnp.Struct(s).Uint64(8)
}

func (s HttpResponse_bodySize) SetFixed(v uint64) {
	capnp.Struct(s).SetUint16(2, 1)
	capnp.Struct(s).SetUint64(8, v)
}

// HttpResponse_List is a list of HttpResponse.
type HttpResponse_List = capnp.StructList[HttpResponse]

// NewHttpResponse creates a new list of HttpResponse.
func NewHttpResponse_List(s *capnp.Segment, sz int32) (HttpResponse_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 2}, sz)
	return capnp.StructList[HttpResponse](l), err
}

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

func (f HttpResponse_Future) Struct() (HttpResponse, error) {
	p, err := f.Future.Ptr()
	return HttpResponse(p.Struct()), err
}
func (p HttpResponse_Future) BodySize() HttpResponse_bodySize_Future {
	return HttpResponse_bodySize_Future{p.Future}
}

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

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

type HttpMethod uint16

// HttpMethod_TypeID is the unique identifier for the type HttpMethod.
const HttpMethod_TypeID = 0x8dbd3c007383731e

// Values of HttpMethod.
const (
	HttpMethod_get         HttpMethod = 0
	HttpMethod_head        HttpMethod = 1
	HttpMethod_post        HttpMethod = 2
	HttpMethod_put         HttpMethod = 3
	HttpMethod_delete      HttpMethod = 4
	HttpMethod_patch       HttpMethod = 5
	HttpMethod_purge       HttpMethod = 6
	HttpMethod_options     HttpMethod = 7
	HttpMethod_trace       HttpMethod = 8
	HttpMethod_copy        HttpMethod = 9
	HttpMethod_lock        HttpMethod = 10
	HttpMethod_mkcol       HttpMethod = 11
	HttpMethod_move        HttpMethod = 12
	HttpMethod_propfind    HttpMethod = 13
	HttpMethod_proppatch   HttpMethod = 14
	HttpMethod_search      HttpMethod = 15
	HttpMethod_unlock      HttpMethod = 16
	HttpMethod_acl         HttpMethod = 17
	HttpMethod_report      HttpMethod = 18
	HttpMethod_mkactivity  HttpMethod = 19
	HttpMethod_checkout    HttpMethod = 20
	HttpMethod_merge       HttpMethod = 21
	HttpMethod_msearch     HttpMethod = 22
	HttpMethod_notify      HttpMethod = 23
	HttpMethod_subscribe   HttpMethod = 24
	HttpMethod_unsubscribe HttpMethod = 25
)

// String returns the enum's constant name.
func (c HttpMethod) String() string {
	switch c {
	case HttpMethod_get:
		return "get"
	case HttpMethod_head:
		return "head"
	case HttpMethod_post:
		return "post"
	case HttpMethod_put:
		return "put"
	case HttpMethod_delete:
		return "delete"
	case HttpMethod_patch:
		return "patch"
	case HttpMethod_purge:
		return "purge"
	case HttpMethod_options:
		return "options"
	case HttpMethod_trace:
		return "trace"
	case HttpMethod_copy:
		return "copy"
	case HttpMethod_lock:
		return "lock"
	case HttpMethod_mkcol:
		return "mkcol"
	case HttpMethod_move:
		return "move"
	case HttpMethod_propfind:
		return "propfind"
	case HttpMethod_proppatch:
		return "proppatch"
	case HttpMethod_search:
		return "search"
	case HttpMethod_unlock:
		return "unlock"
	case HttpMethod_acl:
		return "acl"
	case HttpMethod_report:
		return "report"
	case HttpMethod_mkactivity:
		return "mkactivity"
	case HttpMethod_checkout:
		return "checkout"
	case HttpMethod_merge:
		return "merge"
	case HttpMethod_msearch:
		return "msearch"
	case HttpMethod_notify:
		return "notify"
	case HttpMethod_subscribe:
		return "subscribe"
	case HttpMethod_unsubscribe:
		return "unsubscribe"

	default:
		return ""
	}
}

// HttpMethodFromString returns the enum value with a name,
// or the zero value if there's no such value.
func HttpMethodFromString(c string) HttpMethod {
	switch c {
	case "get":
		return HttpMethod_get
	case "head":
		return HttpMethod_head
	case "post":
		return HttpMethod_post
	case "put":
		return HttpMethod_put
	case "delete":
		return HttpMethod_delete
	case "patch":
		return HttpMethod_patch
	case "purge":
		return HttpMethod_purge
	case "options":
		return HttpMethod_options
	case "trace":
		return HttpMethod_trace
	case "copy":
		return HttpMethod_copy
	case "lock":
		return HttpMethod_lock
	case "mkcol":
		return HttpMethod_mkcol
	case "move":
		return HttpMethod_move
	case "propfind":
		return HttpMethod_propfind
	case "proppatch":
		return HttpMethod_proppatch
	case "search":
		return HttpMethod_search
	case "unlock":
		return HttpMethod_unlock
	case "acl":
		return HttpMethod_acl
	case "report":
		return HttpMethod_report
	case "mkactivity":
		return HttpMethod_mkactivity
	case "checkout":
		return HttpMethod_checkout
	case "merge":
		return HttpMethod_merge
	case "msearch":
		return HttpMethod_msearch
	case "notify":
		return HttpMethod_notify
	case "subscribe":
		return HttpMethod_subscribe
	case "unsubscribe":
		return HttpMethod_unsubscribe

	default:
		return 0
	}
}

type HttpMethod_List = capnp.EnumList[HttpMethod]

func NewHttpMethod_List(s *capnp.Segment, sz int32) (HttpMethod_List, error) {
	return capnp.NewEnumList[HttpMethod](s, sz)
}

type CommonHeaderName uint16

// CommonHeaderName_TypeID is the unique identifier for the type CommonHeaderName.
const CommonHeaderName_TypeID = 0xee4db03aab7fb4be

// Values of CommonHeaderName.
const (
	CommonHeaderName_invalid                  CommonHeaderName = 0
	CommonHeaderName_acceptCharset            CommonHeaderName = 1
	CommonHeaderName_acceptEncoding           CommonHeaderName = 2
	CommonHeaderName_acceptLanguage           CommonHeaderName = 3
	CommonHeaderName_acceptRanges             CommonHeaderName = 4
	CommonHeaderName_accept                   CommonHeaderName = 5
	CommonHeaderName_accessControlAllowOrigin CommonHeaderName = 6
	CommonHeaderName_age                      CommonHeaderName = 7
	CommonHeaderName_allow                    CommonHeaderName = 8
	CommonHeaderName_authorization            CommonHeaderName = 9
	CommonHeaderName_cacheControl             CommonHeaderName = 10
	CommonHeaderName_contentDisposition       CommonHeaderName = 11
	CommonHeaderName_contentEncoding          CommonHeaderName = 12
	CommonHeaderName_contentLanguage          CommonHeaderName = 13
	CommonHeaderName_contentLength            CommonHeaderName = 14
	CommonHeaderName_contentLocation          CommonHeaderName = 15
	CommonHeaderName_contentRange             CommonHeaderName = 16
	CommonHeaderName_contentType              CommonHeaderName = 17
	CommonHeaderName_cookie                   CommonHeaderName = 18
	CommonHeaderName_date                     CommonHeaderName = 19
	CommonHeaderName_etag                     CommonHeaderName = 20
	CommonHeaderName_expect                   CommonHeaderName = 21
	CommonHeaderName_expires                  CommonHeaderName = 22
	CommonHeaderName_from                     CommonHeaderName = 23
	CommonHeaderName_host                     CommonHeaderName = 24
	CommonHeaderName_ifMatch                  CommonHeaderName = 25
	CommonHeaderName_ifModifiedSince          CommonHeaderName = 26
	CommonHeaderName_ifNoneMatch              CommonHeaderName = 27
	CommonHeaderName_ifRange                  CommonHeaderName = 28
	CommonHeaderName_ifUnmodifiedSince        CommonHeaderName = 29
	CommonHeaderName_lastModified             CommonHeaderName = 30
	CommonHeaderName_link                     CommonHeaderName = 31
	CommonHeaderName_location                 CommonHeaderName = 32
	CommonHeaderName_maxForwards              CommonHeaderName = 33
	CommonHeaderName_proxyAuthenticate        CommonHeaderName = 34
	CommonHeaderName_proxyAuthorization       CommonHeaderName = 35
	CommonHeaderName_range                    CommonHeaderName = 36
	CommonHeaderName_referer                  CommonHeaderName = 37
	CommonHeaderName_refresh                  CommonHeaderName = 38
	CommonHeaderName_retryAfter               CommonHeaderName = 39
	CommonHeaderName_server                   CommonHeaderName = 40
	CommonHeaderName_setCookie                CommonHeaderName = 41
	CommonHeaderName_strictTransportSecurity  CommonHeaderName = 42
	CommonHeaderName_transferEncoding         CommonHeaderName = 43
	CommonHeaderName_userAgent                CommonHeaderName = 44
	CommonHeaderName_vary                     CommonHeaderName = 45
	CommonHeaderName_via                      CommonHeaderName = 46
	CommonHeaderName_wwwAuthenticate          CommonHeaderName = 47
)

// String returns the enum's constant name.
func (c CommonHeaderName) String() string {
	switch c {
	case CommonHeaderName_invalid:
		return "invalid"
	case CommonHeaderName_acceptCharset:
		return "acceptCharset"
	case CommonHeaderName_acceptEncoding:
		return "acceptEncoding"
	case CommonHeaderName_acceptLanguage:
		return "acceptLanguage"
	case CommonHeaderName_acceptRanges:
		return "acceptRanges"
	case CommonHeaderName_accept:
		return "accept"
	case CommonHeaderName_accessControlAllowOrigin:
		return "accessControlAllowOrigin"
	case CommonHeaderName_age:
		return "age"
	case CommonHeaderName_allow:
		return "allow"
	case CommonHeaderName_authorization:
		return "authorization"
	case CommonHeaderName_cacheControl:
		return "cacheControl"
	case CommonHeaderName_contentDisposition:
		return "contentDisposition"
	case CommonHeaderName_contentEncoding:
		return "contentEncoding"
	case CommonHeaderName_contentLanguage:
		return "contentLanguage"
	case CommonHeaderName_contentLength:
		return "contentLength"
	case CommonHeaderName_contentLocation:
		return "contentLocation"
	case CommonHeaderName_contentRange:
		return "contentRange"
	case CommonHeaderName_contentType:
		return "contentType"
	case CommonHeaderName_cookie:
		return "cookie"
	case CommonHeaderName_date:
		return "date"
	case CommonHeaderName_etag:
		return "etag"
	case CommonHeaderName_expect:
		return "expect"
	case CommonHeaderName_expires:
		return "expires"
	case CommonHeaderName_from:
		return "from"
	case CommonHeaderName_host:
		return "host"
	case CommonHeaderName_ifMatch:
		return "ifMatch"
	case CommonHeaderName_ifModifiedSince:
		return "ifModifiedSince"
	case CommonHeaderName_ifNoneMatch:
		return "ifNoneMatch"
	case CommonHeaderName_ifRange:
		return "ifRange"
	case CommonHeaderName_ifUnmodifiedSince:
		return "ifUnmodifiedSince"
	case CommonHeaderName_lastModified:
		return "lastModified"
	case CommonHeaderName_link:
		return "link"
	case CommonHeaderName_location:
		return "location"
	case CommonHeaderName_maxForwards:
		return "maxForwards"
	case CommonHeaderName_proxyAuthenticate:
		return "proxyAuthenticate"
	case CommonHeaderName_proxyAuthorization:
		return "proxyAuthorization"
	case CommonHeaderName_range:
		return "range"
	case CommonHeaderName_referer:
		return "referer"
	case CommonHeaderName_refresh:
		return "refresh"
	case CommonHeaderName_retryAfter:
		return "retryAfter"
	case CommonHeaderName_server:
		return "server"
	case CommonHeaderName_setCookie:
		return "setCookie"
	case CommonHeaderName_strictTransportSecurity:
		return "strictTransportSecurity"
	case CommonHeaderName_transferEncoding:
		return "transferEncoding"
	case CommonHeaderName_userAgent:
		return "userAgent"
	case CommonHeaderName_vary:
		return "vary"
	case CommonHeaderName_via:
		return "via"
	case CommonHeaderName_wwwAuthenticate:
		return "wwwAuthenticate"

	default:
		return ""
	}
}

// CommonHeaderNameFromString returns the enum value with a name,
// or the zero value if there's no such value.
func CommonHeaderNameFromString(c string) CommonHeaderName {
	switch c {
	case "invalid":
		return CommonHeaderName_invalid
	case "acceptCharset":
		return CommonHeaderName_acceptCharset
	case "acceptEncoding":
		return CommonHeaderName_acceptEncoding
	case "acceptLanguage":
		return CommonHeaderName_acceptLanguage
	case "acceptRanges":
		return CommonHeaderName_acceptRanges
	case "accept":
		return CommonHeaderName_accept
	case "accessControlAllowOrigin":
		return CommonHeaderName_accessControlAllowOrigin
	case "age":
		return CommonHeaderName_age
	case "allow":
		return CommonHeaderName_allow
	case "authorization":
		return CommonHeaderName_authorization
	case "cacheControl":
		return CommonHeaderName_cacheControl
	case "contentDisposition":
		return CommonHeaderName_contentDisposition
	case "contentEncoding":
		return CommonHeaderName_contentEncoding
	case "contentLanguage":
		return CommonHeaderName_contentLanguage
	case "contentLength":
		return CommonHeaderName_contentLength
	case "contentLocation":
		return CommonHeaderName_contentLocation
	case "contentRange":
		return CommonHeaderName_contentRange
	case "contentType":
		return CommonHeaderName_contentType
	case "cookie":
		return CommonHeaderName_cookie
	case "date":
		return CommonHeaderName_date
	case "etag":
		return CommonHeaderName_etag
	case "expect":
		return CommonHeaderName_expect
	case "expires":
		return CommonHeaderName_expires
	case "from":
		return CommonHeaderName_from
	case "host":
		return CommonHeaderName_host
	case "ifMatch":
		return CommonHeaderName_ifMatch
	case "ifModifiedSince":
		return CommonHeaderName_ifModifiedSince
	case "ifNoneMatch":
		return CommonHeaderName_ifNoneMatch
	case "ifRange":
		return CommonHeaderName_ifRange
	case "ifUnmodifiedSince":
		return CommonHeaderName_ifUnmodifiedSince
	case "lastModified":
		return CommonHeaderName_lastModified
	case "link":
		return CommonHeaderName_link
	case "location":
		return CommonHeaderName_location
	case "maxForwards":
		return CommonHeaderName_maxForwards
	case "proxyAuthenticate":
		return CommonHeaderName_proxyAuthenticate
	case "proxyAuthorization":
		return CommonHeaderName_proxyAuthorization
	case "range":
		return CommonHeaderName_range
	case "referer":
		return CommonHeaderName_referer
	case "refresh":
		return CommonHeaderName_refresh
	case "retryAfter":
		return CommonHeaderName_retryAfter
	case "server":
		return CommonHeaderName_server
	case "setCookie":
		return CommonHeaderName_setCookie
	case "strictTransportSecurity":
		return CommonHeaderName_strictTransportSecurity
	case "transferEncoding":
		return CommonHeaderName_transferEncoding
	case "userAgent":
		return CommonHeaderName_userAgent
	case "vary":
		return CommonHeaderName_vary
	case "via":
		return CommonHeaderName_via
	case "wwwAuthenticate":
		return CommonHeaderName_wwwAuthenticate

	default:
		return 0
	}
}

type CommonHeaderName_List = capnp.EnumList[CommonHeaderName]

func NewCommonHeaderName_List(s *capnp.Segment, sz int32) (CommonHeaderName_List, error) {
	return capnp.NewEnumList[CommonHeaderName](s, sz)
}

type CommonHeaderValue uint16

// CommonHeaderValue_TypeID is the unique identifier for the type CommonHeaderValue.
const CommonHeaderValue_TypeID = 0x83e5f307c4d3785f

// Values of CommonHeaderValue.
const (
	CommonHeaderValue_invalid     CommonHeaderValue = 0
	CommonHeaderValue_gzipDeflate CommonHeaderValue = 1
)

// String returns the enum's constant name.
func (c CommonHeaderValue) String() string {
	switch c {
	case CommonHeaderValue_invalid:
		return "invalid"
	case CommonHeaderValue_gzipDeflate:
		return "gzipDeflate"

	default:
		return ""
	}
}

// CommonHeaderValueFromString returns the enum value with a name,
// or the zero value if there's no such value.
func CommonHeaderValueFromString(c string) CommonHeaderValue {
	switch c {
	case "invalid":
		return CommonHeaderValue_invalid
	case "gzipDeflate":
		return CommonHeaderValue_gzipDeflate

	default:
		return 0
	}
}

type CommonHeaderValue_List = capnp.EnumList[CommonHeaderValue]

func NewCommonHeaderValue_List(s *capnp.Segment, sz int32) (CommonHeaderValue_List, error) {
	return capnp.NewEnumList[CommonHeaderValue](s, sz)
}

type HttpHeader capnp.Struct
type HttpHeader_common HttpHeader
type HttpHeader_Which uint16

const (
	HttpHeader_Which_common   HttpHeader_Which = 0
	HttpHeader_Which_uncommon HttpHeader_Which = 1
)

func (w HttpHeader_Which) String() string {
	const s = "commonuncommon"
	switch w {
	case HttpHeader_Which_common:
		return s[0:6]
	case HttpHeader_Which_uncommon:
		return s[6:14]

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

type HttpHeader_common_Which uint16

const (
	HttpHeader_common_Which_commonValue HttpHeader_common_Which = 0
	HttpHeader_common_Which_value       HttpHeader_common_Which = 1
)

func (w HttpHeader_common_Which) String() string {
	const s = "commonValuevalue"
	switch w {
	case HttpHeader_common_Which_commonValue:
		return s[0:11]
	case HttpHeader_common_Which_value:
		return s[11:16]

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

// HttpHeader_TypeID is the unique identifier for the type HttpHeader.
const HttpHeader_TypeID = 0xb39047580b6fd228

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

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

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

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

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

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

func (s HttpHeader) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}

func (s HttpHeader) Which() HttpHeader_Which {
	return HttpHeader_Which(capnp.Struct(s).Uint16(8))
}
func (s HttpHeader) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

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

func (s HttpHeader) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpHeader) Common() HttpHeader_common { return HttpHeader_common(s) }

func (s HttpHeader) SetCommon() {
	capnp.Struct(s).SetUint16(8, 0)
}

func (s HttpHeader_common) Which() HttpHeader_common_Which {
	return HttpHeader_common_Which(capnp.Struct(s).Uint16(4))
}
func (s HttpHeader_common) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

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

func (s HttpHeader_common) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s HttpHeader_common) Name() CommonHeaderName {
	return CommonHeaderName(capnp.Struct(s).Uint16(0))
}

func (s HttpHeader_common) SetName(v CommonHeaderName) {
	capnp.Struct(s).SetUint16(0, uint16(v))
}

func (s HttpHeader_common) CommonValue() CommonHeaderValue {
	if capnp.Struct(s).Uint16(4) != 0 {
		panic("Which() != commonValue")
	}
	return CommonHeaderValue(capnp.Struct(s).Uint16(2))
}

func (s HttpHeader_common) SetCommonValue(v CommonHeaderValue) {
	capnp.Struct(s).SetUint16(4, 0)
	capnp.Struct(s).SetUint16(2, uint16(v))
}

func (s HttpHeader_common) Value() (string, error) {
	if capnp.Struct(s).Uint16(4) != 1 {
		panic("Which() != value")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s HttpHeader_common) HasValue() bool {
	if capnp.Struct(s).Uint16(4) != 1 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

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

func (s HttpHeader_common) SetValue(v string) error {
	capnp.Struct(s).SetUint16(4, 1)
	return capnp.Struct(s).SetText(0, v)
}

func (s HttpHeader) Uncommon() (HttpHeader_NameValue, error) {
	if capnp.Struct(s).Uint16(8) != 1 {
		panic("Which() != uncommon")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return HttpHeader_NameValue(p.Struct()), err
}

func (s HttpHeader) HasUncommon() bool {
	if capnp.Struct(s).Uint16(8) != 1 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s HttpHeader) SetUncommon(v HttpHeader_NameValue) error {
	capnp.Struct(s).SetUint16(8, 1)
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewUncommon sets the uncommon field to a newly
// allocated HttpHeader_NameValue struct, preferring placement in s's segment.
func (s HttpHeader) NewUncommon() (HttpHeader_NameValue, error) {
	capnp.Struct(s).SetUint16(8, 1)
	ss, err := NewHttpHeader_NameValue(capnp.Struct(s).Segment())
	if err != nil {
		return HttpHeader_NameValue{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// HttpHeader_List is a list of HttpHeader.
type HttpHeader_List = capnp.StructList[HttpHeader]

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

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

func (f HttpHeader_Future) Struct() (HttpHeader, error) {
	p, err := f.Future.Ptr()
	return HttpHeader(p.Struct()), err
}
func (p HttpHeader_Future) Common() HttpHeader_common_Future {
	return HttpHeader_common_Future{p.Future}
}

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

func (f HttpHeader_common_Future) Struct() (HttpHeader_common, error) {
	p, err := f.Future.Ptr()
	return HttpHeader_common(p.Struct()), err
}
func (p HttpHeader_Future) Uncommon() HttpHeader_NameValue_Future {
	return HttpHeader_NameValue_Future{Future: p.Future.Field(0, nil)}
}

type HttpHeader_NameValue capnp.Struct

// HttpHeader_NameValue_TypeID is the unique identifier for the type HttpHeader_NameValue.
const HttpHeader_NameValue_TypeID = 0xed5334c41abc0375

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

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

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

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

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

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

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

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

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

func (s HttpHeader_NameValue) HasName() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

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

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

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

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

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

// HttpHeader_NameValue_List is a list of HttpHeader_NameValue.
type HttpHeader_NameValue_List = capnp.StructList[HttpHeader_NameValue]

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

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

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

const schema_b665280aaff2e632 = "x\xda\xbcY}p\x14\xe7y\x7f\x9e\xdd\xbb[IH" +
	":\xad^\x81\x8dcx\x91\x8c\x13\x909b\xa10\xae" +
	"\x15\xd3C:\xe4\x80\x06\x82V\x12\x900\x8e\xdd\xd5\xdd" +
	"{\xd2\xc2i\xf7\xd8\xddC\x12S\xaa\x82K\\\xe8x" +
	"\xc6fJ[\x18<\x0d\x9dx\xc6\xa4Cm\x92\xdaS" +
	"\x98\x12\x87&\x1e\x8f=\xe9L!\xe3\xdaxbg\x92" +
	")qp\xc7M\xed\xd4m\xc9\x14o\xe7\xd9\xbd\xbd;" +
	"\x09\xe9P\x8a\x9b?@w\xbb\xbf\xe7\xfb\xeb}\x9f\xbb" +
	"?V\xb7>\xd2\xd1\xf0\x97\x0c$\xed_\xa21\xef\xfe" +
	"\xa5O\x1d\xb97\xfb\xf3\x03\xa0>\x80\x00QT\x00:" +
	"_\xac\x1d\x96\x00\xd9\xa5\xda$\xa0\xf7\xd8\xc4\x8f~\xa0" +
	"\xfc\xea\xea\xe3\xa0.\x92\xbc5?\xff\xe8\xf9\xba\x15\xe2" +
	"%\x00\xec\xfc\xb8\xb6\x07Y\xb4N\x01`X\xf7\x00\xa0" +
	"\xf7\xf8\xff\xbc\xb4\x84\xf5\x8e\x1f\x02mQ\xb4f\x1a\xb4" +
	"\xa3\xae\x0eY7A\x07\x1f\xaa\x93\x11\xf0\x97K\x9d\xc7" +
	"\x9d\x87.<9\x93g\x82\x80\xeb\x08\xd8\xf9`\xdd\xb8" +
	"\x04\xe8\xb5\x1d{{G\xff/\x92O\x83\xba\x0c\x01\"" +
	"\xf4\xe6\x8d\x056B\xc4\xdb\xf5\xaf\xf7\x9d\xb9\xf1\xc5?" +
	";\x0a\xea\"y\x1a\x93\x8b\x0b\x9a\x91]Z\xf0\x00\x00" +
	"k\xa8\x7f\x95\x1d\xaeW\x00\xbcko\xedx\xf6\xcdC" +
	"\x8f\x1c\xab\xb4sO\xfd.\xb2\xf3\xc9z\xb2\xf3\x8b\xc9" +
	"\xad?z\xf9\xb3\x7fs\x1c\xd46\xb9\xcc\x1b\xb0\xf3L" +
	"\xfdyd\xaf\x10\x13v\xb1^\xa1\x7f\x00\x1e^~\xff" +
	"\xe4S\xeb\xfe\xf99P\xdb\x88]\x94\xd8\x9d\xae?\x82" +
	"\x80\x9d\xe7\xea9\x02zq\xf9\xf3\xa9\x97\xb6\xfe\xdd\xe9" +
	"@\xf1@\xe0;\x0d\x07\x11\x90]k \x81\xef\xbe\xf2" +
	"\xc9\xfd\xab\x94\xb7O\x17YH\x04\xa8m<O\x80\xc5" +
	"\x8d\xe3\x80\xde=\xcf\xbd\xfe\x1f\xa7;O\xbep\x93\x81" +
	"\x93\x8d\x12\xb2C\x8d\xa4\xd1\x81\xc6W\x19\xc6I\xa3\x15" +
	"\x97\xad\x05_\xf9\xd2S\xdf\x01m\x11V8\xb5\x17\x15" +
	"\x09#\x9d\xd7\x1a\xeb\x90]o\xbc\x03\x80E\xe3\xc4\xfc" +
	"\x83\x7fO}\xdd\xfe\xf5\xeas\xa0\xfenI\xbdM\xf1" +
	"#\xe4\x0f#N\xea\x9dx\xf4\xe1\xad\xbd\xaf\xf3\xf3\xa0" +
	"-\xc3\x12\xe2p|\x17\xe9w\xccg\xb1.\xf7\xd6\x99" +
	"\x1bf\xcb\x85J\x97~\x18\xb7\x89EC\x13\xb18\xff" +
	"\xed\xd7\xd2?\\:\xf4]\xd0\xdaP\xf2\xb2\x1b\xdb\xa3" +
	"g\x9f|\xe1]\xd8&)(!vv4\xed$f" +
	"\xeb\x9a\x88\xd9\xc6\xa3\xebNF[?\xf7r\xd1\x1b>" +
	"\xb3\xe3MG\x09p\xdagV\xf3\xe8\xf1\xc7\xfe %" +
	"\xbd\x0e\xda=(y\xc7\x9b\x07?\xbc{\xed\xda\x8fJ" +
	"\xcc^k\x1a&\xec\x1b>\xb3\xcf\xb4?\xf9\xfc\xe2\xce" +
	"W\x7fX\xe9\xda\x0e\x95\xa2\xc3\xbaU\x02|\xe7\xbf\xfa" +
	"&\xefy\xf9\x97\xd3\x00\xcf\xa8\xdf&\xc0\x19\x1f\xe0d" +
	"\xbbj\xdf?\xfb\xfe?U\xba\xa7\xb6\xf9(\xd9\xb6\xb2" +
	"\x99\xd4Y\xf1\xe6\xf7\xbf\xf9\xe0\xca\x1do\xdf\x94.[" +
	"\x9a?Bf4SpD\xf3\x13\xec\x02}\xf2\xbe?" +
	"\xb1c\xf5\xe1\x87\xaf\xff\xb82\x19\x9em\xf6\x93\xe1\xac" +
	"\xcf\xae\xe4\x9c\xe9\xd1\x0b4\xbb\xd4\xdc\x8c\xec\xa7>\xcb" +
	"w\x9a\xdf\x03\xfcI{\xdf\xbb}K\xf7\\\xd3ZQ" +
	"*\xc7}\x1b\x92'\xa4\xce\xd3\xac\xc7\xe7\xcb\x9e\xa7\x10" +
	"\xa4\x17<\x92\xdf\xbe\xe6\xfd\x9b\xd5l9\x8fL\xb4\x10" +
	"O\xbd\xe5\x09v\x8e>y\x05\xf9\xef\xef\xfa\xc1\x17\x06" +
	"?\x00\xb5\x15\xcb\x8c\x03%N\xb5\xecD\xf6\xa2Op" +
	"\xb6\x85\\\xf4\xdd\xbf\x9d\xfa\xeb\xae\x17\xb6\xfc\xdbM\x8d" +
	"\xa1aa\x17\xb2%\x0b\x89h\xf1\xc2'\"\x80\xe5h" +
	"\xcdf\xdd\x15~\x17\xb2k\x9c\x18_\xe5\xef\x01z\x17" +
	"/\xb7>\xba~\xc1\xa1\xff,\xe6\x95\x0f:\xb7\xcc/" +
	"\xd57\x96\x91\xe4C\xff\xfd\xf5?\xe9\xf9\xc5\x81\xeb\xc4" +
	"\x0e\xcb\xec\xfc\xe6\xd0\xdb\xba\x06\xd9\xb6V\xe2\xa6\xb5\x92" +
	"g\xf7\x7f\xe9\xbe\x13'\x8e9\xbf\x0e\"\xe9c\xf6\xb4" +
	"\x9e\x90 \xe2\xa5V-\x1c\x7fs\x81|\xa32\xe5\xf6" +
	"\xb4\xfa)w\xc0'\xcd\x1c\xf8\xc9\xd5\x7f\xfcf\xe3'" +
	"\x95I\xf0l\xebAR\xe4bk\x12~\xe5\x8d\xban" +
	">a\xed\x155v\"\xad\xe7\xcd\xfcj\xff\xff\xae\x8d" +
	"\xae\x9b\x1f\x14\xf6^#-V\xa7r\x860\xdd\x01\xb1" +
	"\xa7 \x1c7e\x99\xae\x98pW;\xaen\xbb\x03\xc2" +
	"\xc9[\xa6#\x96\xf7\xeb\xb6\xa2\x8f9ZD\x8e\x00D" +
	"\x10@m\xe8\x03\xd0\xeae\xd4\xee\x94\xd0\xb3\x8b8\x00" +
	"\xc0\xa6\xb2+\x01\xb1\x09\xb0\xa4Bd\xba\x0a)kl" +
	"\xcc27\x0a=#\xec\xedz\xae \xa0\x1fQ\xabA" +
	"\x09@U{\x88X\xad\x1dV\x1b\xf8\x94a\xee\xd5s" +
	"F\xc6\x1b\xd9g\xe47\x88l\x0e\x14\xdd\x15Z\x04\xa5" +
	"\x8av\x1e\x91\xb0\xbb\x05\xb1\x1e@E\xdbG\xaeZ\x96" +
	"\x11\xc0\xb39\xdd\x15\x00%\x1d\xe4\xe9:\xa4}\x1d\x86" +
	"\xc4\x84\x0b$\x1d\xebA\x9a\x0bJ\x1e\xdb\"\xdcQ+" +
	"\xe3C\xb5QR\x94u`\x1bi\xcaVb;\x00J" +
	"\xac\xd5\xff+\xb3\xc5\xfe\xf3\x08S\xb1\x0b\x00\xa3\xac\x16" +
	"\xd7\x00`\x8c\xa1\xffWQ\xaf\x93\x815\xea\x87\xf4\xad" +
	"V\xbdFDu\xeaO\xe9\xcf\x02\xf5\x0a=\xacW/" +
	"\xd1\xb7\x06\xf5\xb5>\x00lT_\x19\x00\xc0\xb8z\x91" +
	"\xd85\xa9\xe7\xe8\x8f\xaa\x9e%!\xcd\xeai\xfa\xc6\xd4" +
	"S;\x01\xb0E}\x86\x08\x16\xaa\xc7\x89\xcb\"\xf5i" +
	"\x12t\x87z\x98 w\xaa\x07\x88\xcbbu\xff0\x80" +
	"2\"\xdc\xf8\xa8\xd03\xf1\xbc\xe5\xb8J\xbe\xe0&3" +
	"\"'\\\xc1\xf3\xba\x9b\x1e\xe5\xf9\x82=\"\xa6\xac\xbc" +
	"kX\xa6\xc3][O\x8bx\xda\xcaO\xc6sVz" +
	"7\x1f\xdb\x9d\xb6r\xf11k\xaf\xf0\xf2\xb6\x95\xcf\x1a" +
	"f\x06\x00\xfc\xcfD\x0e8\x9at\x84n\xa7G\x93\x05" +
	"\x93\x08\x14=\x9dK\xda\"o\xd9\xae7\xb6[O\xbb" +
	"\xc6^\x03dw\xd2K\x8f\x8a\xf4n\xab\xe0\x02\x00\x1f" +
	"\x13$r\xacHhZ\xae\x91\x9d\xf4\x9c\xc2\xb0\x93\xb6" +
	"\x8da@\xe1\x15\xcc\xe0\x1b(\xc6\xb0\x98+\xafv\x88" +
	"\xe1A+\xbd[\xb8\xab\xd39\xcb\x11\xcb\x07\x04w\x0a" +
	"9\xd7\xa9\x16\xd8\xa0\x14Ph\xf5X\xd9\x90\xd4oU" +
	"4\xd1\x85?\xab\x18\xc0K\xbe\xe5\x85e\x83a\xdd\xc4" +
	"\xa9p\xbc\x94e\x9a\"\xed\xa6\xa4\x99U\xa5\xd0[\x12" +
	"$\xec\x99DZ\xbd\x1c\xc5r\xcb\xc7p\xee\xaa\xda." +
	"\x90\xd4M\xd4\xf7\xc2y\x81aKP\xd7\xf5\x80\xa4v" +
	"((\x95&=\x86\x13J\xbd\x97\xde-V\xbcb\x15" +
	"\xef\x818\x89[\x8fSv\xa0\xcfz\x9cJ\x07z\xae" +
	"\xc7~\xc4O\xa9K\x0c\x08'N\x9e\xael\x13\xed\x00" +
	"Z\x8d\x8cZ\x8b\x84\xf1a+3\x89\xaa\x97\xfd\xf3\xba" +
	"\x1f\x7f\xe3\xad\xf7.\xfb%^\xd1\x1f\xa2s\x0b\x0f\xdd" +
	"\x16\x08O\x06\xd2\xfb\x11\xfb\xe5h\xa5\xfaU8\x14\xcd" +
	"\xa5N\xa6\x8f9\x00ZKI\xc7\xfd\xa4\xe3\x84\x8c\xda" +
	"\x1fI\xa8\"\xb6\xd0YB=\xd0\x03\xa0\xfd\xbe\x8c\xda" +
	"_H\xa8JR\x8b\xdf\x96\x8e\x11\xf2)\x19\xb5\x93\x12" +
	"\xaa\xb2\xdc\x822\x80z\x9c\x90\x7f*\xa3\xf6\x0d\x09\xd5" +
	"H\xa4\x05#\x00~\x11j'e\xd4\x9e\x930>j" +
	"9.\xb5\x16\xac\x07\x9c\x1a\xf5\x1b\x9e\x83\x8d\x80\xfd2" +
	"bSy\x88\x01\xd2\xc3x\xc6\x1a7o\xf6\x12\xc5\x8b" +
	"\x8cF\xb5\x9c\x92E\xff9\xc2u\x0ds\xc4\x09\xbao" +
	"i\xf2\xcc\xe8\xbe\xd1\xb9\xaa\xc4\x11ff\x83\xee\xea\xa1" +
	"k\xe6\x8a^Fwul\x00\x09\x1b\xe6\x17\xb30\xf7" +
	"(d\xcb\x07\x92\xc2/B\xad\xa6\xc4|\xe50\x80\xb6" +
	"BF\xed\x0b\x15n\xef g\xae\x92Q\xfb\x1d\x7f\xac" +
	"\xf8\xc4=\xa0\xcc\x9a8\x15.)\x15\xe6\x8c\x94\x92\xe7" +
	"0\xda\xef\xe0\xf5r\xb4\xe2\xdc\x83\xe6\xd9\xef\x8dw\x9e" +
	"x\xec\xb8\xaa\xf5\xf9E\x87\xe5\x03r\xf9\xdd:z\xb7" +
	"\x96\x8a.<|bx\xfcWW\xae\x01I]\xa2x" +
	"\xe4\xd0`\xa4\xc0z\xf4B\xf7\xfa\xdf\xb8\xdf\x92\xa6\xd7" +
	"\xdc,\xed(\x18\x8a\x00Z\x04\xb1\xe2\xc4\x83\x03\xde\x97" +
	"\xf51A\xc3\x12P\x90+\xeb=\x0fKg-ue" +
	"\x17H\x0d\xf8\x89\x17\xe4\xa5J)\xd8$\xa3v\xb7\x84" +
	"\xc9`\xd0y\x053\xf8\x10\xa4J\x89\xf3\x8cT\xa9\xad" +
	"\xd2\x05\x8a\xddm\xcef\xd0k\xdb\x96M\x9d\x80\xa2\x0d" +
	"\xf0\x7fl\x05\xb7h\xe9\xfdz\x9cR\xb52\x99\x88\xf9" +
	"r\x19\xb5\xfb%\x0cs)\xd1UN\xb0x\xda\xca\x08" +
	"T@B\x050i\x0b\xdd\xb1\xcc\xb0$o\xaf\xfb\x95" +
	"t+\x0d\x9aJ\x9bwV\x9c\x92\xa8\xb0\x09\x0a\xb2\xa0" +
	"\x9c-\xdd\x9d\xaa\xdbNZ\x14\xe5\xae&\xaf\x0d\x1a\xf2" +
	"\xbe0\xf6A\xa0W\xf6\x94m_\x82\x9fx\x18\xb4\xa0" +
	"\xc4\x9a\xb2\xf9S\x05s\xb7i\x8d\x9b\x10\xe3YcB" +
	"d\xb0\x16$\xac\x85\xdf\xa8s\x061\xc5i\xe6\xddU" +
	"\x0e\xa9\\\xc8\xcf?\xa0\x81Q\xc1\xd8\x08\xacR\x8c\xdf" +
	"\xaeU\xc5\xdeR\x9e\x07\x15\xb9T!\xb9\xd4\x98\x12=" +
	"\x15r\x8b\xc4\xd8T\xbe\x14\x05%T\xd1\x92J\xa7\x88" +
	"\xf9O\xb9i\x1d\xb3\x9f\xeb3s\xfc\xffU\xaf\xdb)" +
	"\xfaT\xe5p\xc5\xdb\xbc&\xc4~SExx\x1a\xd0" +
	"j\xfc\x8e\x1e^\x8c1\xbcW\xa9\x1dt\x8cZI\x1d" +
	"=\xbc/a\xb8\\P\x97\xec\x04I]X<*\xa5" +
	",\x13\xe2\xc1\xb1\xc8\x0b\xdb\x19\xc8\x96=\xbdcW\x1d" +
	"\xa5\xd4\xf9o5J\xfdP\xcc\xec>\xf2\\u\x8f\xbe" +
	"mM%V:\xf5\xb5Gd\xd4F\xcb\xbdN\xb4\x01" +
	"h\xbf'\xa3\x96\xa3\xe3\x0a\x06\xc7\x15\x83r##\xa3" +
	"\xf6\x87\x12\xa2\x8c\x15\xdb\x0eu\x7f\x1fH\xc91\xff:" +
	"\x83\xf1p\xd5\x05\x88q@\xa5`\xe7\xe6}Z\xf1\x82" +
	"\x96\xb4\x8fbZ\xad\xd8\x83\x89\xb6\xba8}\xb4\xfa\x92" +
	"1\xbd\xe4\x97\xf52j\x9b\xa9\xcc=\xafh\xcf&:" +
	"\x1cl\x94Q\x1b\x92\xb0A\xa2\x91F\x06iT\xfc\x9b" +
	"e\xd4\xbe\"a\xdc\xd4\xc7\x04\xc6\xcbw\xfc@{/" +
	"\x10\xb1]\x07%W\xa0\xf7\xa5\xe5`\xf0\x9e\xef\xa5\xab" +
	"\xe6M\xce\x8f\xce\xb7\xf5\x97\xcf\x9e\xc5l\x0b\xb7\x93\x18" +
	"\xae\xef\xd4\x0e;\xcc\xb6pM\x80\xe1\x1eJ]\xb2\xaf" +
	"\"\xdb\x06\x84\x03\xdc\xaf\x880\xddv\x88aH\x06\xc9" +
	"4=\xe5\xe6vi\xf1D \x17D\xa0\xd3l\x13\xb1" +
	"\xdc-*\xbag\xe0\xc0\xa2#\xe6p\x8b<\xd7\x95=" +
	")l\x12L\"\xbf\xe7_\x84\x1f\x94\xfc+;\xeb\x90" +
	"l\xb6V\xe2(\xb1m\xd2>\xf6U\x89\xa3\xcc&\xa5" +
	"}l\xbf\xc41\xc2\x9e\x91v\xb1S\x12\xc7(\xbb(" +
	"u\xb1\x8b\x12\xc7\x18{Gz\x9d]\x938*L\x95" +
	"\xdb\x98*s\xaca\x09y\x0dK\xc8\x1ck\xd9&\xd9" +
	"f[d\x8eulL\xde\xc5\xf6\xc8\x1c\x17\xb0\xa7\xe5" +
	"\x13\xec\xb8\xcc\xb1\x9e]\x90\x0f\xb2\x8b2\xc7\x06vU" +
	">\xc8\xae\xc9\x1c\x1bYC\xc4fj\x84c\x9cuD" +
	"\x0e\xb2\xb5\x11\x8eM\xec\xab\x91]\xeck\x11\x8e*\xdb" +
	"\x1f\x19f\x07\"\x1c\x9b\xd9\xa9H\x17;\x15\xe1\xc8\xd8" +
	"\x85H;\xbb\x10\xe1\xd8\xc2\xaeD\xda\xd9\x95\x08\xc7\x85" +
	"\xec\xe3H\x17\xfb8\xc2q\x11S\xa3=L\x8dr\xbc" +
	"\x83%\xa2\xed,\x11\xe5x'\xdb\x14mg\x9b\xa2\x1c" +
	"\x173\x11\xeda\"\xca\xf1.v(z\x90\x1d\x8er" +
	"\xfc\x0c;\x13\x1dfg\xa3\x1c\xeff\x97\xa2=\xecR" +
	"\x94\xe3\x12\xf6a\xf4(\xbb\x1e\xe5\xb8\x94-\x89\xedb" +
	"\xad1\x8e\x9cu\xc7\xdaYw\x8c\xe32\xf6\xb5X\x1f" +
	"\xd3c\x1c[\xd9\x81\xd80;\x14\xe3\xd8\xc6\x9e\x8d\x1d" +
	"egb\x1c\xefa\x97b'\xd8\x95\x18\xc7\xe5\xecF" +
	"l\x0d\xbb\x11\xe3x/[\xac\xf4\xb0\xc5\x0a\xc7\xcf\xb2" +
	"\xb5J\x0f[\xabp\xfc\x1c\xd3\x94\x9dl\x9b\xc2q\x05" +
	"+(]\xac\xa0p\\\xc9\x9eV\x06\xd81\x85c;" +
	"{Q\xf9\x07vA\xe1x\x1f\xbb\xaa\x1ca\x1f(\x1c" +
	"W1\xb5f\x80-\xac\xe1\x98`kk\xda\xd9\xda\x1a" +
	"\x8e\xab\x99V\xd3\xc6\xb4\x1a\x8e\x9fgc5\x07\xd9\x9e" +
	"\x9a\xf2\x02FO\xa7E\xdeM\x8d\x02\xd7mG\xb8U" +
	"V0\xfb\xbcn\x1f\x9bHAr\xd4\x07\x03\x14\xc9{" +
	"MH\xa6\xad\x8ca\x8eT\xa1?\x18\xd2\xf7\xa2\x19\x80" +
	"\xa1\xc4`\xb3\x0eIs\xa4\xa0\x8f\x88\xf90\xd8\x8cz" +
	"\x00.3\x18\xd0!n\x8e\x08\xa7\xea\x0a\xa9H>\x00" +
	"\\',@2 \x9e\x85\xa8\xa9H\xd4\x95\x0c\x88\x8a" +
	"\x82\x1c'eI\xa6k[\xb9\xee\\\xce\x1a\xdfj\x1b" +
	"#\x86\xe9\x9f\xe9g2\xb8\xbb\xc8\xe0g\xbeT\xc7I" +
	"\xa4$\xcb'L\xf8\x94\x89\xad\xb6\xa1\xf8\xb4\xca\xecF" +
	"\x87\x0a\xb4)\xddd'\xd7\x89\xaa\x0an\x0d\xf7\xf9\x92" +
	"\x9e\x05w\xd4\xb2\x8d}\xc0u\xd7\xb0\xcc\xea\x1e\x99\x8e" +
	"\x05\xf0\xd2zzT\xf8#\x93\x94\xadJ\x9c\"h\"" +
	"e\x01\xf7\x0d#bj\xa4\xa6\xbb\x01\x0d'o9\x86" +
	"k\xc8\xb3\xca\xbf\xb3\xc8\xe2\xaf\xbcT@\x90\xc0\x0dE" +
	"\x0a\xa5\xa8E\xf0\xbc\x9c)U\xb8\x1c)s\xe9\x0d\xe1" +
	"\x18r(\xa7\xca\xfc8l\x0e\xe1e\x0e\xc0\x859\xe2" +
	"\x8eV\xad\x8c\x90\x1e\x92\x9b}p\xd9\x84\xcdh\xa5\x03" +
	"\xdf\xceS\x81\x10^R`\x00\xe2\x94\xae\xd5C\x11\xca" +
	"\xe7\x03\x84-\x8b\x1f\x02e2_\x8dvW\x996>" +
	"4\x99\x17@\x95l\xed6D\xd5\xa2H\xf9\x10\x80x" +
	"f\xf6\xb5m\x88l\x8fo\xf0w\xb5q\xe1\xea#U" +
	"q\xbdC\xfa\x08@RL\xe4E\xbazA\xf6\xfa\x10" +
	"\x80)1\x917\xecYK>\x04\xf7L\xf5\x06\x18\x80" +
	"x\xd6\xb6\xc6\xaaj\xf0\xb0m\x8d\x01\xf8\x8b\x9d\xaa\xb8" +
	"\x8d\x96C\xd2\x8d\xec\x16\xddMWK\x8b>oS6" +
	"\xe1\x83\x00\xd03\xb2[\xac\x8c\x915Pd\x06\x0d3" +
	"]5!\x8f\xfa\x94\x04GCd\x12\x84G\x0a\xaa\x91" +
	"\xfd\xb2e\x8a-:(\xd5%\xdbDO\xd0\x04\xf0\xa2" +
	"\x02SFv\xe0\x16i\xe4\xeb[\xcc\x1f\xd2w\x9b9" +
	"fe\x0c\xcc\x1a\x81\xc6(\xaa\x96\xf2\xa6l\xc2'@" +
	"#\x1b\xe8\xac\x90\x91\xe0\xe5t\xc7%S N\xcf\xab" +
	"*\xbdYw\\2\x1b\xb8\xcf\x03 \x9e3\xcc\xddU" +
	"\x83\xb1\xd90w\x93\x90\xb0jf\xed\xc5e\x03K\xd5" +
	"\x05\xe8\x8d\xe9\x13\x0f[\xf6\xb8\x0e\x8a\x9dq\xaaV\xc8" +
	"\x16}\"AP\x88\xebv\xc6\x09V\xe2\x13\x93\xdd\x05" +
	"\x17G\x85\xe9\x1ai\xdd\xad\xea\x9b\x13^?\xe1\x13\xdd" +
	"\x05t\x8b\x04\xb2\xff\x03F\x99\x0d\xf5`\xfd\xd6\xed\xb2" +
	"\x82O@\x11\xb4Kn\xcf\x11\xd9\xf2p(\x86u\xca" +
	"\x16Ya\x0b\xbbj\xcd\x0c\x04\x98\x00m\x0bg\xf4V" +
	"h\xc2\x00x\xb6p\xed\xc9\xee\xac\x0b\xf2\xac\x02B\x7f" +
	"\x0e{\x03\x04LtgAqIL\xd2\xf17\xc1U" +
	"\x8b>X\x16\xd3EP\xb8~\xf3\x01\xac\x96\xca;\xbd" +
	"A\xe1&\x08\x082\xf5)\xcfqm#\xed\x0e\xd9\x92" +
	"n:y\xcbv\x07E\xba`\x1b\xeed\xb5\xd1}\xd9" +
	"\x1b\xf4\xa9\x12C\x92]$K\x14\xe9p\x12\xc0s\xe9" +
	"iV\xd8\xe5\xb1S\xbd\xa6\x87B|\xa2H\x80#\x00" +
	"^\xc1\x11v\xf7\x880\x01\xdd\xaa\x06ms\x84\x9d\xa0" +
	"\xb3\x80l\xba\x00\xf1\xbd\xba=Y\xb52\xb6\xeb\xf6$" +
	"\x80\xb2\xd7\xd0\xab\x9e.\xb6\x1b:\x807>>NG" +
	"\x01\x81A:\xdfbZ\xee\xd8\xb1#Ap\x14!\xfc" +
	"\x167^'o\x99\xb2#f\\yw\x96\xaf\xb7\xe1" +
	"]\xc6\xa0g\xa32jn\xc5\x95w\x0f]ys2" +
	"j\x7f\\\xbc\xf2\x96~\x93W\x0f\xf5\x81D\xb7,\xb7" +
	"\xe0\xa4,\x90\xcb\xeb\xc0\xe2\xc3!\x01\xf2\x84{{7" +
	"\xdf\xdb\xdc \xce\xb2\xd7\x0cw>\xeb+nq\xeb\xfa" +
	"\x00\xb4\x87d\xd46J\xf3\xd0\xb3\x90/\xee\xbc\x01\xaa" +
	"l\x1do\xba\xe9\xf9\x9b\x96A\xe1r\xff\xb7\x05\x0aG" +
	"\xc52\xa3\xab\xbc\xccH\x16\x1c1\x94s\x10AB\xfc" +
	"\x94\xf7I\xfe\xcaQ\xae\xf8\xe9n\x1e\x0b\xbd\xd9\xd6\x94" +
	"\xc3\xd3\x96PU\x7fT\xf8\x14\x97\xe0\xb3,\x81\xe6\xbd" +
	"\x0d\xfb\xdf\x00\x00\x00\xff\xff)\xed{\xa2"

func RegisterSchema(reg *schemas.Registry) {
	reg.Register(&schemas.Schema{
		String: schema_b665280aaff2e632,
		Nodes: []uint64{
			0x81e666258a901e30,
			0x83e5f307c4d3785f,
			0x857745131db6fc83,
			0x8dbd3c007383731e,
			0x913fe85057da9522,
			0x92963bfdad2beb6a,
			0x955c85d7a557d8e9,
			0x99ae26bfd34f3f3b,
			0xa8d63d909cead201,
			0xa9b84fb6432f030f,
			0xa9da072c30fec5de,
			0xb09c33a9f4caa823,
			0xb39047580b6fd228,
			0xb92efa728643f0ed,
			0xba1fca454f465e9a,
			0xbd146efdadd86c3d,
			0xbe541ecc63c9b2ba,
			0xbf2721059c3d9248,
			0xca02437e5f995e08,
			0xccc73319af8d2a1b,
			0xccefbf23794af7b3,
			0xd0eab1ea093a6673,
			0xda572939a4c3d728,
			0xdcf946892e5778c3,
			0xdeb08db1052a4866,
			0xe971001e4ade4a2a,
			0xea3256705c0b63ba,
			0xed5334c41abc0375,
			0xee4db03aab7fb4be,
			0xf235351cf1531299,
			0xf6850b405e21d2c1,
			0xf981e8428b86f885,
			0xfa73959a9a2b477d,
			0xfd030bd777152c43,
			0xfe0ea4cde5df8164,
		},
		Compressed: true,
	})
}
