tools/fidl/fidlgen_go/goldens/protocols.go.golden

// Code generated by fidlgen; DO NOT EDIT.

package protocols

import (
	_zx "syscall/zx"
	_bindings "syscall/zx/fidl"
)

var _ _bindings.Enum = ErrorEnum(0)

type ErrorEnum uint32

const (
	ErrorEnumErrFoo ErrorEnum = 1
	ErrorEnumErrBar ErrorEnum = 2
)

func (_ ErrorEnum) I_EnumValues() []ErrorEnum {
	return []ErrorEnum{
		ErrorEnumErrFoo,
		ErrorEnumErrBar,
	}
}

func (_ ErrorEnum) I_EnumIsStrict() bool {
	return true
}

func (x ErrorEnum) IsUnknown() bool {
	switch x {
	case 1:
		return false
	case 2:
		return false
	}
	return true
}

func (x ErrorEnum) String() string {
	switch x {
	case 1:
		return "ErrFoo"
	case 2:
		return "ErrBar"
	}
	return "Unknown"
}

type ProtocolEnds struct {
	_         struct{}                                    `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"4"`
	Client    DiscoverableProtocolWithCtxInterface        `fidl_offset_v2:"0" fidl_handle_subtype:"4"`
	Server    DiscoverableProtocolWithCtxInterfaceRequest `fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
	ClientOpt DiscoverableProtocolWithCtxInterface        `fidl_offset_v2:"8" fidl_handle_subtype:"4"`
	ServerOpt DiscoverableProtocolWithCtxInterfaceRequest `fidl_offset_v2:"12" fidl_handle_subtype:"4" fidl_bounds:"1"`
}

var _mProtocolEnds = _bindings.CreateLazyMarshaler(ProtocolEnds{})

func (msg *ProtocolEnds) Marshaler() _bindings.Marshaler {
	return _mProtocolEnds
}

type WithErrorSyntaxErrorAsEnumResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mWithErrorSyntaxErrorAsEnumResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsEnumResponse{})

func (msg *WithErrorSyntaxErrorAsEnumResponse) Marshaler() _bindings.Marshaler {
	return _mWithErrorSyntaxErrorAsEnumResponse
}

type WithErrorSyntaxErrorAsPrimitiveResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}

var _mWithErrorSyntaxErrorAsPrimitiveResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsPrimitiveResponse{})

func (msg *WithErrorSyntaxErrorAsPrimitiveResponse) Marshaler() _bindings.Marshaler {
	return _mWithErrorSyntaxErrorAsPrimitiveResponse
}

type WithErrorSyntaxHandleInResultResponse struct {
	_ struct{}   `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	H _zx.Handle `fidl_offset_v2:"0" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mWithErrorSyntaxHandleInResultResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxHandleInResultResponse{})

func (msg *WithErrorSyntaxHandleInResultResponse) Marshaler() _bindings.Marshaler {
	return _mWithErrorSyntaxHandleInResultResponse
}

type WithErrorSyntaxResponseAsStructResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
	A int64    `fidl_offset_v2:"0"`
	B int64    `fidl_offset_v2:"8"`
	C int64    `fidl_offset_v2:"16"`
}

var _mWithErrorSyntaxResponseAsStructResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxResponseAsStructResponse{})

func (msg *WithErrorSyntaxResponseAsStructResponse) Marshaler() _bindings.Marshaler {
	return _mWithErrorSyntaxResponseAsStructResponse
}

type channelProtocolWithCtxMethodARequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	A int64    `fidl_offset_v2:"0"`
	B int64    `fidl_offset_v2:"8"`
}

var _mchannelProtocolWithCtxMethodARequest = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMethodARequest{})

func (msg *channelProtocolWithCtxMethodARequest) Marshaler() _bindings.Marshaler {
	return _mchannelProtocolWithCtxMethodARequest
}

type channelProtocolWithCtxEventAResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	A int64    `fidl_offset_v2:"0"`
	B int64    `fidl_offset_v2:"8"`
}

var _mchannelProtocolWithCtxEventAResponse = _bindings.CreateLazyMarshaler(channelProtocolWithCtxEventAResponse{})

func (msg *channelProtocolWithCtxEventAResponse) Marshaler() _bindings.Marshaler {
	return _mchannelProtocolWithCtxEventAResponse
}

type channelProtocolWithCtxMethodBRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	A int64    `fidl_offset_v2:"0"`
	B int64    `fidl_offset_v2:"8"`
}

var _mchannelProtocolWithCtxMethodBRequest = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMethodBRequest{})

func (msg *channelProtocolWithCtxMethodBRequest) Marshaler() _bindings.Marshaler {
	return _mchannelProtocolWithCtxMethodBRequest
}

type channelProtocolWithCtxMethodBResponse struct {
	_      struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Result int64    `fidl_offset_v2:"0"`
}

var _mchannelProtocolWithCtxMethodBResponse = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMethodBResponse{})

func (msg *channelProtocolWithCtxMethodBResponse) Marshaler() _bindings.Marshaler {
	return _mchannelProtocolWithCtxMethodBResponse
}

type channelProtocolWithCtxTakeHandleRequest struct {
	_ struct{}   `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	H _zx.Handle `fidl_offset_v2:"0" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mchannelProtocolWithCtxTakeHandleRequest = _bindings.CreateLazyMarshaler(channelProtocolWithCtxTakeHandleRequest{})

func (msg *channelProtocolWithCtxTakeHandleRequest) Marshaler() _bindings.Marshaler {
	return _mchannelProtocolWithCtxTakeHandleRequest
}

type channelProtocolWithCtxMutateSocketRequest struct {
	_ struct{}   `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	A _zx.Socket `fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mchannelProtocolWithCtxMutateSocketRequest = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMutateSocketRequest{})

func (msg *channelProtocolWithCtxMutateSocketRequest) Marshaler() _bindings.Marshaler {
	return _mchannelProtocolWithCtxMutateSocketRequest
}

type channelProtocolWithCtxMutateSocketResponse struct {
	_ struct{}   `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	B _zx.Socket `fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mchannelProtocolWithCtxMutateSocketResponse = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMutateSocketResponse{})

func (msg *channelProtocolWithCtxMutateSocketResponse) Marshaler() _bindings.Marshaler {
	return _mchannelProtocolWithCtxMutateSocketResponse
}

type handleRightsProtocolWithCtxNoResponseMethodRequest struct {
	_ struct{}   `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	H _zx.Socket `fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"3" fidl_bounds:"0"`
}

var _mhandleRightsProtocolWithCtxNoResponseMethodRequest = _bindings.CreateLazyMarshaler(handleRightsProtocolWithCtxNoResponseMethodRequest{})

func (msg *handleRightsProtocolWithCtxNoResponseMethodRequest) Marshaler() _bindings.Marshaler {
	return _mhandleRightsProtocolWithCtxNoResponseMethodRequest
}

type handleRightsProtocolWithCtxResponseMethodRequest struct {
	_ struct{}   `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	H _zx.Socket `fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"3" fidl_bounds:"0"`
}

var _mhandleRightsProtocolWithCtxResponseMethodRequest = _bindings.CreateLazyMarshaler(handleRightsProtocolWithCtxResponseMethodRequest{})

func (msg *handleRightsProtocolWithCtxResponseMethodRequest) Marshaler() _bindings.Marshaler {
	return _mhandleRightsProtocolWithCtxResponseMethodRequest
}

type handleRightsProtocolWithCtxResponseMethodResponse struct {
	_ struct{}   `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	H _zx.Socket `fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"2" fidl_bounds:"0"`
}

var _mhandleRightsProtocolWithCtxResponseMethodResponse = _bindings.CreateLazyMarshaler(handleRightsProtocolWithCtxResponseMethodResponse{})

func (msg *handleRightsProtocolWithCtxResponseMethodResponse) Marshaler() _bindings.Marshaler {
	return _mhandleRightsProtocolWithCtxResponseMethodResponse
}

type handleRightsProtocolWithCtxAnEventResponse struct {
	_ struct{}   `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	H _zx.Socket `fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"3" fidl_bounds:"0"`
}

var _mhandleRightsProtocolWithCtxAnEventResponse = _bindings.CreateLazyMarshaler(handleRightsProtocolWithCtxAnEventResponse{})

func (msg *handleRightsProtocolWithCtxAnEventResponse) Marshaler() _bindings.Marshaler {
	return _mhandleRightsProtocolWithCtxAnEventResponse
}

type manyParametersWithCtxFifteenRequest struct {
	_   struct{} `fidl:"s" fidl_size_v2:"15" fidl_alignment_v2:"1"`
	P1  bool     `fidl_offset_v2:"0"`
	P2  bool     `fidl_offset_v2:"1"`
	P3  bool     `fidl_offset_v2:"2"`
	P4  bool     `fidl_offset_v2:"3"`
	P5  bool     `fidl_offset_v2:"4"`
	P6  bool     `fidl_offset_v2:"5"`
	P7  bool     `fidl_offset_v2:"6"`
	P8  bool     `fidl_offset_v2:"7"`
	P9  bool     `fidl_offset_v2:"8"`
	P10 bool     `fidl_offset_v2:"9"`
	P11 bool     `fidl_offset_v2:"10"`
	P12 bool     `fidl_offset_v2:"11"`
	P13 bool     `fidl_offset_v2:"12"`
	P14 bool     `fidl_offset_v2:"13"`
	P15 bool     `fidl_offset_v2:"14"`
}

var _mmanyParametersWithCtxFifteenRequest = _bindings.CreateLazyMarshaler(manyParametersWithCtxFifteenRequest{})

func (msg *manyParametersWithCtxFifteenRequest) Marshaler() _bindings.Marshaler {
	return _mmanyParametersWithCtxFifteenRequest
}

type methodWithUnionWithCtxUnionMethodRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	U TheUnion `fidl_offset_v2:"0"`
}

var _mmethodWithUnionWithCtxUnionMethodRequest = _bindings.CreateLazyMarshaler(methodWithUnionWithCtxUnionMethodRequest{})

func (msg *methodWithUnionWithCtxUnionMethodRequest) Marshaler() _bindings.Marshaler {
	return _mmethodWithUnionWithCtxUnionMethodRequest
}

type methodWithUnionWithCtxUnionMethodResponse struct {
	_ struct{}  `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	U *TheUnion `fidl_offset_v2:"0"`
}

var _mmethodWithUnionWithCtxUnionMethodResponse = _bindings.CreateLazyMarshaler(methodWithUnionWithCtxUnionMethodResponse{})

func (msg *methodWithUnionWithCtxUnionMethodResponse) Marshaler() _bindings.Marshaler {
	return _mmethodWithUnionWithCtxUnionMethodResponse
}

type syscallProtocolWithCtxMethodCRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	A int64    `fidl_offset_v2:"0"`
	B int64    `fidl_offset_v2:"8"`
}

var _msyscallProtocolWithCtxMethodCRequest = _bindings.CreateLazyMarshaler(syscallProtocolWithCtxMethodCRequest{})

func (msg *syscallProtocolWithCtxMethodCRequest) Marshaler() _bindings.Marshaler {
	return _msyscallProtocolWithCtxMethodCRequest
}

type transitionalWithCtxRequestRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	X int64    `fidl_offset_v2:"0"`
}

var _mtransitionalWithCtxRequestRequest = _bindings.CreateLazyMarshaler(transitionalWithCtxRequestRequest{})

func (msg *transitionalWithCtxRequestRequest) Marshaler() _bindings.Marshaler {
	return _mtransitionalWithCtxRequestRequest
}

type transitionalWithCtxRequestResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	Y int64    `fidl_offset_v2:"0"`
}

var _mtransitionalWithCtxRequestResponse = _bindings.CreateLazyMarshaler(transitionalWithCtxRequestResponse{})

func (msg *transitionalWithCtxRequestResponse) Marshaler() _bindings.Marshaler {
	return _mtransitionalWithCtxRequestResponse
}

type transitionalWithCtxOneWayRequest struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	X int64    `fidl_offset_v2:"0"`
}

var _mtransitionalWithCtxOneWayRequest = _bindings.CreateLazyMarshaler(transitionalWithCtxOneWayRequest{})

func (msg *transitionalWithCtxOneWayRequest) Marshaler() _bindings.Marshaler {
	return _mtransitionalWithCtxOneWayRequest
}

type transitionalWithCtxEventResponse struct {
	_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
	X int64    `fidl_offset_v2:"0"`
}

var _mtransitionalWithCtxEventResponse = _bindings.CreateLazyMarshaler(transitionalWithCtxEventResponse{})

func (msg *transitionalWithCtxEventResponse) Marshaler() _bindings.Marshaler {
	return _mtransitionalWithCtxEventResponse
}

type withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse struct {
	_   struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Ret string   `fidl_offset_v2:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse{})

func (msg *withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse) Marshaler() _bindings.Marshaler {
	return _mwithAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse
}

type withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest struct {
	_   struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Arg string   `fidl_offset_v2:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest{})

func (msg *withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest) Marshaler() _bindings.Marshaler {
	return _mwithAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest
}

type withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest struct {
	_   struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Arg string   `fidl_offset_v2:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest{})

func (msg *withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest) Marshaler() _bindings.Marshaler {
	return _mwithAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest
}

type withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest struct {
	_   struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Arg string   `fidl_offset_v2:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest{})

func (msg *withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest) Marshaler() _bindings.Marshaler {
	return _mwithAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest
}

type withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse struct {
	_   struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Ret string   `fidl_offset_v2:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse{})

func (msg *withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse) Marshaler() _bindings.Marshaler {
	return _mwithAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse
}

type withAndWithoutRequestResponseWithCtxOnWithResponseResponse struct {
	_   struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Ret string   `fidl_offset_v2:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxOnWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxOnWithResponseResponse{})

func (msg *withAndWithoutRequestResponseWithCtxOnWithResponseResponse) Marshaler() _bindings.Marshaler {
	return _mwithAndWithoutRequestResponseWithCtxOnWithResponseResponse
}

type withErrorSyntaxWithCtxResponseAsStructResponse struct {
	_      struct{}                              `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result WithErrorSyntaxResponseAsStructResult `fidl_offset_v2:"0"`
}

var _mwithErrorSyntaxWithCtxResponseAsStructResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxWithCtxResponseAsStructResponse{})

func (msg *withErrorSyntaxWithCtxResponseAsStructResponse) Marshaler() _bindings.Marshaler {
	return _mwithErrorSyntaxWithCtxResponseAsStructResponse
}

type withErrorSyntaxWithCtxErrorAsPrimitiveResponse struct {
	_      struct{}                              `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result WithErrorSyntaxErrorAsPrimitiveResult `fidl_offset_v2:"0"`
}

var _mwithErrorSyntaxWithCtxErrorAsPrimitiveResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxWithCtxErrorAsPrimitiveResponse{})

func (msg *withErrorSyntaxWithCtxErrorAsPrimitiveResponse) Marshaler() _bindings.Marshaler {
	return _mwithErrorSyntaxWithCtxErrorAsPrimitiveResponse
}

type withErrorSyntaxWithCtxErrorAsEnumResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result WithErrorSyntaxErrorAsEnumResult `fidl_offset_v2:"0"`
}

var _mwithErrorSyntaxWithCtxErrorAsEnumResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxWithCtxErrorAsEnumResponse{})

func (msg *withErrorSyntaxWithCtxErrorAsEnumResponse) Marshaler() _bindings.Marshaler {
	return _mwithErrorSyntaxWithCtxErrorAsEnumResponse
}

type withErrorSyntaxWithCtxHandleInResultResponse struct {
	_      struct{}                            `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Result WithErrorSyntaxHandleInResultResult `fidl_offset_v2:"0"`
}

var _mwithErrorSyntaxWithCtxHandleInResultResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxWithCtxHandleInResultResponse{})

func (msg *withErrorSyntaxWithCtxHandleInResultResponse) Marshaler() _bindings.Marshaler {
	return _mwithErrorSyntaxWithCtxHandleInResultResponse
}

type withProtocolEndsWithCtxClientEndsRequest struct {
	_  struct{}                             `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	In DiscoverableProtocolWithCtxInterface `fidl_offset_v2:"0" fidl_handle_subtype:"4"`
}

var _mwithProtocolEndsWithCtxClientEndsRequest = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxClientEndsRequest{})

func (msg *withProtocolEndsWithCtxClientEndsRequest) Marshaler() _bindings.Marshaler {
	return _mwithProtocolEndsWithCtxClientEndsRequest
}

type withProtocolEndsWithCtxClientEndsResponse struct {
	_   struct{}                             `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Out DiscoverableProtocolWithCtxInterface `fidl_offset_v2:"0" fidl_handle_subtype:"4"`
}

var _mwithProtocolEndsWithCtxClientEndsResponse = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxClientEndsResponse{})

func (msg *withProtocolEndsWithCtxClientEndsResponse) Marshaler() _bindings.Marshaler {
	return _mwithProtocolEndsWithCtxClientEndsResponse
}

type withProtocolEndsWithCtxServerEndsRequest struct {
	_  struct{}                                    `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	In DiscoverableProtocolWithCtxInterfaceRequest `fidl_offset_v2:"0" fidl_handle_subtype:"4" fidl_bounds:"1"`
}

var _mwithProtocolEndsWithCtxServerEndsRequest = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxServerEndsRequest{})

func (msg *withProtocolEndsWithCtxServerEndsRequest) Marshaler() _bindings.Marshaler {
	return _mwithProtocolEndsWithCtxServerEndsRequest
}

type withProtocolEndsWithCtxServerEndsResponse struct {
	_   struct{}                                    `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	Out DiscoverableProtocolWithCtxInterfaceRequest `fidl_offset_v2:"0" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mwithProtocolEndsWithCtxServerEndsResponse = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxServerEndsResponse{})

func (msg *withProtocolEndsWithCtxServerEndsResponse) Marshaler() _bindings.Marshaler {
	return _mwithProtocolEndsWithCtxServerEndsResponse
}

type withProtocolEndsWithCtxStructContainingEndsRequest struct {
	_  struct{}     `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"4"`
	In ProtocolEnds `fidl_offset_v2:"0"`
}

var _mwithProtocolEndsWithCtxStructContainingEndsRequest = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxStructContainingEndsRequest{})

func (msg *withProtocolEndsWithCtxStructContainingEndsRequest) Marshaler() _bindings.Marshaler {
	return _mwithProtocolEndsWithCtxStructContainingEndsRequest
}

type withProtocolEndsWithCtxStructContainingEndsResponse struct {
	_   struct{}     `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"4"`
	Out ProtocolEnds `fidl_offset_v2:"0"`
}

var _mwithProtocolEndsWithCtxStructContainingEndsResponse = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxStructContainingEndsResponse{})

func (msg *withProtocolEndsWithCtxStructContainingEndsResponse) Marshaler() _bindings.Marshaler {
	return _mwithProtocolEndsWithCtxStructContainingEndsResponse
}

type I_theUnionTag uint64

const (
	TheUnion_unknownData = 0 // 0x00000000
	TheUnionV            = 1 // 0x00000001
)

type TheUnion struct {
	I_theUnionTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	V             uint32 `fidl_ordinal:"1"`
}

var _mTheUnion = _bindings.CreateLazyMarshaler(TheUnion{})

func (msg *TheUnion) Marshaler() _bindings.Marshaler {
	return _mTheUnion
}

func (_m *TheUnion) reset() {
	switch _m.I_theUnionTag {
	case 1:
		var _zeroed uint32
		_m.V = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *TheUnion) Which() I_theUnionTag {
	switch _m.I_theUnionTag {
	case 1:
		return TheUnionV
	default:
		return TheUnion_unknownData
	}
}

func (_m *TheUnion) Ordinal() uint64 {
	return uint64(_m.I_theUnionTag)
}

func (_m *TheUnion) SetV(v uint32) {
	_m.reset()
	_m.I_theUnionTag = TheUnionV
	_m.V = v
}

func TheUnionWithV(v uint32) TheUnion {
	var _u TheUnion
	_u.SetV(v)
	return _u
}
func (_m *TheUnion) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_withErrorSyntaxErrorAsEnumResultTag uint64

const (
	WithErrorSyntaxErrorAsEnumResultResponse = 1 // 0x00000001
	WithErrorSyntaxErrorAsEnumResultErr      = 2 // 0x00000002
)

type WithErrorSyntaxErrorAsEnumResult struct {
	I_withErrorSyntaxErrorAsEnumResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                              WithErrorSyntaxErrorAsEnumResponse `fidl_ordinal:"1"`
	Err                                   ErrorEnum                          `fidl_ordinal:"2"`
}

var _mWithErrorSyntaxErrorAsEnumResult = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsEnumResult{})

func (msg *WithErrorSyntaxErrorAsEnumResult) Marshaler() _bindings.Marshaler {
	return _mWithErrorSyntaxErrorAsEnumResult
}

func (_m *WithErrorSyntaxErrorAsEnumResult) reset() {
	switch _m.I_withErrorSyntaxErrorAsEnumResultTag {
	case 1:
		var _zeroed WithErrorSyntaxErrorAsEnumResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed ErrorEnum
		_m.Err = _zeroed
	}
}

func (_m *WithErrorSyntaxErrorAsEnumResult) Which() I_withErrorSyntaxErrorAsEnumResultTag {
	return _m.I_withErrorSyntaxErrorAsEnumResultTag
}

func (_m *WithErrorSyntaxErrorAsEnumResult) Ordinal() uint64 {
	return uint64(_m.I_withErrorSyntaxErrorAsEnumResultTag)
}

func (_m *WithErrorSyntaxErrorAsEnumResult) SetResponse(response WithErrorSyntaxErrorAsEnumResponse) {
	_m.reset()
	_m.I_withErrorSyntaxErrorAsEnumResultTag = WithErrorSyntaxErrorAsEnumResultResponse
	_m.Response = response
}

func WithErrorSyntaxErrorAsEnumResultWithResponse(response WithErrorSyntaxErrorAsEnumResponse) WithErrorSyntaxErrorAsEnumResult {
	var _u WithErrorSyntaxErrorAsEnumResult
	_u.SetResponse(response)
	return _u
}

func (_m *WithErrorSyntaxErrorAsEnumResult) SetErr(err ErrorEnum) {
	_m.reset()
	_m.I_withErrorSyntaxErrorAsEnumResultTag = WithErrorSyntaxErrorAsEnumResultErr
	_m.Err = err
}

func WithErrorSyntaxErrorAsEnumResultWithErr(err ErrorEnum) WithErrorSyntaxErrorAsEnumResult {
	var _u WithErrorSyntaxErrorAsEnumResult
	_u.SetErr(err)
	return _u
}

type I_withErrorSyntaxErrorAsPrimitiveResultTag uint64

const (
	WithErrorSyntaxErrorAsPrimitiveResultResponse = 1 // 0x00000001
	WithErrorSyntaxErrorAsPrimitiveResultErr      = 2 // 0x00000002
)

type WithErrorSyntaxErrorAsPrimitiveResult struct {
	I_withErrorSyntaxErrorAsPrimitiveResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                   WithErrorSyntaxErrorAsPrimitiveResponse `fidl_ordinal:"1"`
	Err                                        uint32                                  `fidl_ordinal:"2"`
}

var _mWithErrorSyntaxErrorAsPrimitiveResult = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsPrimitiveResult{})

func (msg *WithErrorSyntaxErrorAsPrimitiveResult) Marshaler() _bindings.Marshaler {
	return _mWithErrorSyntaxErrorAsPrimitiveResult
}

func (_m *WithErrorSyntaxErrorAsPrimitiveResult) reset() {
	switch _m.I_withErrorSyntaxErrorAsPrimitiveResultTag {
	case 1:
		var _zeroed WithErrorSyntaxErrorAsPrimitiveResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed uint32
		_m.Err = _zeroed
	}
}

func (_m *WithErrorSyntaxErrorAsPrimitiveResult) Which() I_withErrorSyntaxErrorAsPrimitiveResultTag {
	return _m.I_withErrorSyntaxErrorAsPrimitiveResultTag
}

func (_m *WithErrorSyntaxErrorAsPrimitiveResult) Ordinal() uint64 {
	return uint64(_m.I_withErrorSyntaxErrorAsPrimitiveResultTag)
}

func (_m *WithErrorSyntaxErrorAsPrimitiveResult) SetResponse(response WithErrorSyntaxErrorAsPrimitiveResponse) {
	_m.reset()
	_m.I_withErrorSyntaxErrorAsPrimitiveResultTag = WithErrorSyntaxErrorAsPrimitiveResultResponse
	_m.Response = response
}

func WithErrorSyntaxErrorAsPrimitiveResultWithResponse(response WithErrorSyntaxErrorAsPrimitiveResponse) WithErrorSyntaxErrorAsPrimitiveResult {
	var _u WithErrorSyntaxErrorAsPrimitiveResult
	_u.SetResponse(response)
	return _u
}

func (_m *WithErrorSyntaxErrorAsPrimitiveResult) SetErr(err uint32) {
	_m.reset()
	_m.I_withErrorSyntaxErrorAsPrimitiveResultTag = WithErrorSyntaxErrorAsPrimitiveResultErr
	_m.Err = err
}

func WithErrorSyntaxErrorAsPrimitiveResultWithErr(err uint32) WithErrorSyntaxErrorAsPrimitiveResult {
	var _u WithErrorSyntaxErrorAsPrimitiveResult
	_u.SetErr(err)
	return _u
}

type I_withErrorSyntaxHandleInResultResultTag uint64

const (
	WithErrorSyntaxHandleInResultResultResponse = 1 // 0x00000001
	WithErrorSyntaxHandleInResultResultErr      = 2 // 0x00000002
)

type WithErrorSyntaxHandleInResultResult struct {
	I_withErrorSyntaxHandleInResultResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"`
	Response                                 WithErrorSyntaxHandleInResultResponse `fidl_ordinal:"1"`
	Err                                      uint32                                `fidl_ordinal:"2"`
}

var _mWithErrorSyntaxHandleInResultResult = _bindings.CreateLazyMarshaler(WithErrorSyntaxHandleInResultResult{})

func (msg *WithErrorSyntaxHandleInResultResult) Marshaler() _bindings.Marshaler {
	return _mWithErrorSyntaxHandleInResultResult
}

func (_m *WithErrorSyntaxHandleInResultResult) reset() {
	switch _m.I_withErrorSyntaxHandleInResultResultTag {
	case 1:
		var _zeroed WithErrorSyntaxHandleInResultResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed uint32
		_m.Err = _zeroed
	}
}

func (_m *WithErrorSyntaxHandleInResultResult) Which() I_withErrorSyntaxHandleInResultResultTag {
	return _m.I_withErrorSyntaxHandleInResultResultTag
}

func (_m *WithErrorSyntaxHandleInResultResult) Ordinal() uint64 {
	return uint64(_m.I_withErrorSyntaxHandleInResultResultTag)
}

func (_m *WithErrorSyntaxHandleInResultResult) SetResponse(response WithErrorSyntaxHandleInResultResponse) {
	_m.reset()
	_m.I_withErrorSyntaxHandleInResultResultTag = WithErrorSyntaxHandleInResultResultResponse
	_m.Response = response
}

func WithErrorSyntaxHandleInResultResultWithResponse(response WithErrorSyntaxHandleInResultResponse) WithErrorSyntaxHandleInResultResult {
	var _u WithErrorSyntaxHandleInResultResult
	_u.SetResponse(response)
	return _u
}

func (_m *WithErrorSyntaxHandleInResultResult) SetErr(err uint32) {
	_m.reset()
	_m.I_withErrorSyntaxHandleInResultResultTag = WithErrorSyntaxHandleInResultResultErr
	_m.Err = err
}

func WithErrorSyntaxHandleInResultResultWithErr(err uint32) WithErrorSyntaxHandleInResultResult {
	var _u WithErrorSyntaxHandleInResultResult
	_u.SetErr(err)
	return _u
}

type I_withErrorSyntaxResponseAsStructResultTag uint64

const (
	WithErrorSyntaxResponseAsStructResultResponse = 1 // 0x00000001
	WithErrorSyntaxResponseAsStructResultErr      = 2 // 0x00000002
)

type WithErrorSyntaxResponseAsStructResult struct {
	I_withErrorSyntaxResponseAsStructResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                   WithErrorSyntaxResponseAsStructResponse `fidl_ordinal:"1"`
	Err                                        uint32                                  `fidl_ordinal:"2"`
}

var _mWithErrorSyntaxResponseAsStructResult = _bindings.CreateLazyMarshaler(WithErrorSyntaxResponseAsStructResult{})

func (msg *WithErrorSyntaxResponseAsStructResult) Marshaler() _bindings.Marshaler {
	return _mWithErrorSyntaxResponseAsStructResult
}

func (_m *WithErrorSyntaxResponseAsStructResult) reset() {
	switch _m.I_withErrorSyntaxResponseAsStructResultTag {
	case 1:
		var _zeroed WithErrorSyntaxResponseAsStructResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed uint32
		_m.Err = _zeroed
	}
}

func (_m *WithErrorSyntaxResponseAsStructResult) Which() I_withErrorSyntaxResponseAsStructResultTag {
	return _m.I_withErrorSyntaxResponseAsStructResultTag
}

func (_m *WithErrorSyntaxResponseAsStructResult) Ordinal() uint64 {
	return uint64(_m.I_withErrorSyntaxResponseAsStructResultTag)
}

func (_m *WithErrorSyntaxResponseAsStructResult) SetResponse(response WithErrorSyntaxResponseAsStructResponse) {
	_m.reset()
	_m.I_withErrorSyntaxResponseAsStructResultTag = WithErrorSyntaxResponseAsStructResultResponse
	_m.Response = response
}

func WithErrorSyntaxResponseAsStructResultWithResponse(response WithErrorSyntaxResponseAsStructResponse) WithErrorSyntaxResponseAsStructResult {
	var _u WithErrorSyntaxResponseAsStructResult
	_u.SetResponse(response)
	return _u
}

func (_m *WithErrorSyntaxResponseAsStructResult) SetErr(err uint32) {
	_m.reset()
	_m.I_withErrorSyntaxResponseAsStructResultTag = WithErrorSyntaxResponseAsStructResultErr
	_m.Err = err
}

func WithErrorSyntaxResponseAsStructResultWithErr(err uint32) WithErrorSyntaxResponseAsStructResult {
	var _u WithErrorSyntaxResponseAsStructResult
	_u.SetErr(err)
	return _u
}

const ()

type AnotherDiscoverableProtocolWithCtxInterface _bindings.ChannelProxy

type AnotherDiscoverableProtocolWithCtx interface {
}

type AnotherDiscoverableProtocolWithCtxTransitionalBase struct{}

type AnotherDiscoverableProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewAnotherDiscoverableProtocolWithCtxInterfaceRequest() (AnotherDiscoverableProtocolWithCtxInterfaceRequest, *AnotherDiscoverableProtocolWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return AnotherDiscoverableProtocolWithCtxInterfaceRequest(req), (*AnotherDiscoverableProtocolWithCtxInterface)(cli), err
}

// Implements ServiceRequest.
func (_ AnotherDiscoverableProtocolWithCtxInterfaceRequest) Name() string {
	return "fake.library.FakeProtocol"
}
func (c AnotherDiscoverableProtocolWithCtxInterfaceRequest) ToChannel() _zx.Channel {
	return c.Channel
}

const AnotherDiscoverableProtocolName = "fake.library.FakeProtocol"

type AnotherDiscoverableProtocolWithCtxStub struct {
	Impl AnotherDiscoverableProtocolWithCtx
}

func (s_ *AnotherDiscoverableProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type AnotherDiscoverableProtocolEventProxy _bindings.ChannelProxy

const (
	ChannelProtocolMethodAOrdinal      uint64 = 0x2bc8d7d32bc66ba2
	ChannelProtocolEventAOrdinal       uint64 = 0x1ed0a220297145ce
	ChannelProtocolMethodBOrdinal      uint64 = 0x7b8dd3d6c741c9c6
	ChannelProtocolTakeHandleOrdinal   uint64 = 0x836fa31201a0a65
	ChannelProtocolMutateSocketOrdinal uint64 = 0x66dbcccc06f7f14f
)

type ChannelProtocolWithCtxInterface _bindings.ChannelProxy

func (p *ChannelProtocolWithCtxInterface) MethodA(ctx_ _bindings.Context, a int64, b int64) error {
	req_ := &channelProtocolWithCtxMethodARequest{A: a, B: b}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(ChannelProtocolMethodAOrdinal, req_)
	return err_
}

func (p *ChannelProtocolWithCtxInterface) ExpectEventA(ctx_ _bindings.Context) (int64, int64, error) {
	resp_ := &channelProtocolWithCtxEventAResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(ChannelProtocolEventAOrdinal, resp_)
	return (*resp_).A, (*resp_).B, err_
}

func (p *ChannelProtocolWithCtxInterface) MethodB(ctx_ _bindings.Context, a int64, b int64) (int64, error) {
	req_ := &channelProtocolWithCtxMethodBRequest{A: a, B: b}
	resp_ := &channelProtocolWithCtxMethodBResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ChannelProtocolMethodBOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *ChannelProtocolWithCtxInterface) TakeHandle(ctx_ _bindings.Context, h _zx.Handle) error {
	req_ := &channelProtocolWithCtxTakeHandleRequest{H: h}
	var resp_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ChannelProtocolTakeHandleOrdinal, req_, resp_)
	return err_
}

func (p *ChannelProtocolWithCtxInterface) MutateSocket(ctx_ _bindings.Context, a _zx.Socket) (_zx.Socket, error) {
	req_ := &channelProtocolWithCtxMutateSocketRequest{A: a}
	resp_ := &channelProtocolWithCtxMutateSocketResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ChannelProtocolMutateSocketOrdinal, req_, resp_)
	return (*resp_).B, err_
}

type ChannelProtocolWithCtx interface {
	MethodA(ctx_ _bindings.Context, a int64, b int64) error
	MethodB(ctx_ _bindings.Context, a int64, b int64) (int64, error)
	TakeHandle(ctx_ _bindings.Context, h _zx.Handle) error
	MutateSocket(ctx_ _bindings.Context, a _zx.Socket) (_zx.Socket, error)
}

type ChannelProtocolWithCtxTransitionalBase struct{}

type ChannelProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewChannelProtocolWithCtxInterfaceRequest() (ChannelProtocolWithCtxInterfaceRequest, *ChannelProtocolWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return ChannelProtocolWithCtxInterfaceRequest(req), (*ChannelProtocolWithCtxInterface)(cli), err
}

type ChannelProtocolWithCtxStub struct {
	Impl ChannelProtocolWithCtx
}

func (s_ *ChannelProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case ChannelProtocolMethodAOrdinal:
		in_ := &channelProtocolWithCtxMethodARequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.MethodA(args_.Ctx, (*in_).A, (*in_).B)
		return nil, false, err_
	case ChannelProtocolMethodBOrdinal:
		in_ := &channelProtocolWithCtxMethodBRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		result, err_ := s_.Impl.MethodB(args_.Ctx, (*in_).A, (*in_).B)
		out_ := &channelProtocolWithCtxMethodBResponse{Result: result}
		return out_, true, err_
	case ChannelProtocolTakeHandleOrdinal:
		in_ := &channelProtocolWithCtxTakeHandleRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.TakeHandle(args_.Ctx, (*in_).H)
		return nil, true, err_
	case ChannelProtocolMutateSocketOrdinal:
		in_ := &channelProtocolWithCtxMutateSocketRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		b, err_ := s_.Impl.MutateSocket(args_.Ctx, (*in_).A)
		out_ := &channelProtocolWithCtxMutateSocketResponse{B: b}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type ChannelProtocolEventProxy _bindings.ChannelProxy

func (p *ChannelProtocolEventProxy) EventA(a int64, b int64) error {
	event_ := &channelProtocolWithCtxEventAResponse{A: a, B: b}
	return ((*_bindings.ChannelProxy)(p)).Send(ChannelProtocolEventAOrdinal, event_)
}

const (
	DiscoverableProtocolMethodOrdinal uint64 = 0x2ff5ba3a2bd170eb
)

type DiscoverableProtocolWithCtxInterface _bindings.ChannelProxy

func (p *DiscoverableProtocolWithCtxInterface) Method(ctx_ _bindings.Context) error {
	var req_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Send(DiscoverableProtocolMethodOrdinal, req_)
	return err_
}

type DiscoverableProtocolWithCtx interface {
	Method(ctx_ _bindings.Context) error
}

type DiscoverableProtocolWithCtxTransitionalBase struct{}

type DiscoverableProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewDiscoverableProtocolWithCtxInterfaceRequest() (DiscoverableProtocolWithCtxInterfaceRequest, *DiscoverableProtocolWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return DiscoverableProtocolWithCtxInterfaceRequest(req), (*DiscoverableProtocolWithCtxInterface)(cli), err
}

// Implements ServiceRequest.
func (_ DiscoverableProtocolWithCtxInterfaceRequest) Name() string {
	return "test.protocols.DiscoverableProtocol"
}
func (c DiscoverableProtocolWithCtxInterfaceRequest) ToChannel() _zx.Channel {
	return c.Channel
}

const DiscoverableProtocolName = "test.protocols.DiscoverableProtocol"

type DiscoverableProtocolWithCtxStub struct {
	Impl DiscoverableProtocolWithCtx
}

func (s_ *DiscoverableProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case DiscoverableProtocolMethodOrdinal:
		err_ := s_.Impl.Method(args_.Ctx)
		return nil, false, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type DiscoverableProtocolEventProxy _bindings.ChannelProxy

const (
	HandleRightsProtocolNoResponseMethodOrdinal uint64 = 0x10078afd320d2bfd
	HandleRightsProtocolResponseMethodOrdinal   uint64 = 0x52a8f194ac143547
	HandleRightsProtocolAnEventOrdinal          uint64 = 0x69dad41418eb133
)

type HandleRightsProtocolWithCtxInterface _bindings.ChannelProxy

func (p *HandleRightsProtocolWithCtxInterface) NoResponseMethod(ctx_ _bindings.Context, h _zx.Socket) error {
	req_ := &handleRightsProtocolWithCtxNoResponseMethodRequest{H: h}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(HandleRightsProtocolNoResponseMethodOrdinal, req_)
	return err_
}

func (p *HandleRightsProtocolWithCtxInterface) ResponseMethod(ctx_ _bindings.Context, h _zx.Socket) (_zx.Socket, error) {
	req_ := &handleRightsProtocolWithCtxResponseMethodRequest{H: h}
	resp_ := &handleRightsProtocolWithCtxResponseMethodResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(HandleRightsProtocolResponseMethodOrdinal, req_, resp_)
	return (*resp_).H, err_
}

func (p *HandleRightsProtocolWithCtxInterface) ExpectAnEvent(ctx_ _bindings.Context) (_zx.Socket, error) {
	resp_ := &handleRightsProtocolWithCtxAnEventResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(HandleRightsProtocolAnEventOrdinal, resp_)
	return (*resp_).H, err_
}

type HandleRightsProtocolWithCtx interface {
	NoResponseMethod(ctx_ _bindings.Context, h _zx.Socket) error
	ResponseMethod(ctx_ _bindings.Context, h _zx.Socket) (_zx.Socket, error)
}

type HandleRightsProtocolWithCtxTransitionalBase struct{}

type HandleRightsProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewHandleRightsProtocolWithCtxInterfaceRequest() (HandleRightsProtocolWithCtxInterfaceRequest, *HandleRightsProtocolWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return HandleRightsProtocolWithCtxInterfaceRequest(req), (*HandleRightsProtocolWithCtxInterface)(cli), err
}

type HandleRightsProtocolWithCtxStub struct {
	Impl HandleRightsProtocolWithCtx
}

func (s_ *HandleRightsProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case HandleRightsProtocolNoResponseMethodOrdinal:
		in_ := &handleRightsProtocolWithCtxNoResponseMethodRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.NoResponseMethod(args_.Ctx, (*in_).H)
		return nil, false, err_
	case HandleRightsProtocolResponseMethodOrdinal:
		in_ := &handleRightsProtocolWithCtxResponseMethodRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		h, err_ := s_.Impl.ResponseMethod(args_.Ctx, (*in_).H)
		out_ := &handleRightsProtocolWithCtxResponseMethodResponse{H: h}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type HandleRightsProtocolEventProxy _bindings.ChannelProxy

func (p *HandleRightsProtocolEventProxy) AnEvent(h _zx.Socket) error {
	event_ := &handleRightsProtocolWithCtxAnEventResponse{H: h}
	return ((*_bindings.ChannelProxy)(p)).Send(HandleRightsProtocolAnEventOrdinal, event_)
}

const (
	ManyParametersFifteenOrdinal uint64 = 0x59233bcecd338967
)

type ManyParametersWithCtxInterface _bindings.ChannelProxy

func (p *ManyParametersWithCtxInterface) Fifteen(ctx_ _bindings.Context, p1 bool, p2 bool, p3 bool, p4 bool, p5 bool, p6 bool, p7 bool, p8 bool, p9 bool, p10 bool, p11 bool, p12 bool, p13 bool, p14 bool, p15 bool) error {
	req_ := &manyParametersWithCtxFifteenRequest{P1: p1, P2: p2, P3: p3, P4: p4, P5: p5, P6: p6, P7: p7, P8: p8, P9: p9, P10: p10, P11: p11, P12: p12, P13: p13, P14: p14, P15: p15}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(ManyParametersFifteenOrdinal, req_)
	return err_
}

type ManyParametersWithCtx interface {
	Fifteen(ctx_ _bindings.Context, p1 bool, p2 bool, p3 bool, p4 bool, p5 bool, p6 bool, p7 bool, p8 bool, p9 bool, p10 bool, p11 bool, p12 bool, p13 bool, p14 bool, p15 bool) error
}

type ManyParametersWithCtxTransitionalBase struct{}

type ManyParametersWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewManyParametersWithCtxInterfaceRequest() (ManyParametersWithCtxInterfaceRequest, *ManyParametersWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return ManyParametersWithCtxInterfaceRequest(req), (*ManyParametersWithCtxInterface)(cli), err
}

type ManyParametersWithCtxStub struct {
	Impl ManyParametersWithCtx
}

func (s_ *ManyParametersWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case ManyParametersFifteenOrdinal:
		in_ := &manyParametersWithCtxFifteenRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.Fifteen(args_.Ctx, (*in_).P1, (*in_).P2, (*in_).P3, (*in_).P4, (*in_).P5, (*in_).P6, (*in_).P7, (*in_).P8, (*in_).P9, (*in_).P10, (*in_).P11, (*in_).P12, (*in_).P13, (*in_).P14, (*in_).P15)
		return nil, false, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type ManyParametersEventProxy _bindings.ChannelProxy

const (
	MethodWithUnionUnionMethodOrdinal uint64 = 0x393e7f5b2b821218
)

type MethodWithUnionWithCtxInterface _bindings.ChannelProxy

func (p *MethodWithUnionWithCtxInterface) UnionMethod(ctx_ _bindings.Context, u TheUnion) (*TheUnion, error) {
	req_ := &methodWithUnionWithCtxUnionMethodRequest{U: u}
	resp_ := &methodWithUnionWithCtxUnionMethodResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(MethodWithUnionUnionMethodOrdinal, req_, resp_)
	return (*resp_).U, err_
}

type MethodWithUnionWithCtx interface {
	UnionMethod(ctx_ _bindings.Context, u TheUnion) (*TheUnion, error)
}

type MethodWithUnionWithCtxTransitionalBase struct{}

type MethodWithUnionWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewMethodWithUnionWithCtxInterfaceRequest() (MethodWithUnionWithCtxInterfaceRequest, *MethodWithUnionWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return MethodWithUnionWithCtxInterfaceRequest(req), (*MethodWithUnionWithCtxInterface)(cli), err
}

type MethodWithUnionWithCtxStub struct {
	Impl MethodWithUnionWithCtx
}

func (s_ *MethodWithUnionWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case MethodWithUnionUnionMethodOrdinal:
		in_ := &methodWithUnionWithCtxUnionMethodRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		u, err_ := s_.Impl.UnionMethod(args_.Ctx, (*in_).U)
		out_ := &methodWithUnionWithCtxUnionMethodResponse{U: u}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type MethodWithUnionEventProxy _bindings.ChannelProxy

const (
	TransitionalRequestOrdinal uint64 = 0x512cc1ba467fef08
	TransitionalOneWayOrdinal  uint64 = 0x3c2ee8512dc7f7e7
	TransitionalEventOrdinal   uint64 = 0x76113c4b4d484841
)

type TransitionalWithCtxInterface _bindings.ChannelProxy

func (p *TransitionalWithCtxInterface) Request(ctx_ _bindings.Context, x int64) (int64, error) {
	req_ := &transitionalWithCtxRequestRequest{X: x}
	resp_ := &transitionalWithCtxRequestResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(TransitionalRequestOrdinal, req_, resp_)
	return (*resp_).Y, err_
}

func (p *TransitionalWithCtxInterface) OneWay(ctx_ _bindings.Context, x int64) error {
	req_ := &transitionalWithCtxOneWayRequest{X: x}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(TransitionalOneWayOrdinal, req_)
	return err_
}

func (p *TransitionalWithCtxInterface) ExpectEvent(ctx_ _bindings.Context) (int64, error) {
	resp_ := &transitionalWithCtxEventResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(TransitionalEventOrdinal, resp_)
	return (*resp_).X, err_
}

type TransitionalWithCtx interface {
	Request(ctx_ _bindings.Context, x int64) (int64, error)
	OneWay(ctx_ _bindings.Context, x int64) error
}

type TransitionalWithCtxTransitionalBase struct{}

func (_ *TransitionalWithCtxTransitionalBase) Request(ctx_ _bindings.Context, x int64) (int64, error) {
	panic("Not Implemented")
}
func (_ *TransitionalWithCtxTransitionalBase) OneWay(ctx_ _bindings.Context, x int64) error {
	panic("Not Implemented")
}

type TransitionalWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewTransitionalWithCtxInterfaceRequest() (TransitionalWithCtxInterfaceRequest, *TransitionalWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return TransitionalWithCtxInterfaceRequest(req), (*TransitionalWithCtxInterface)(cli), err
}

type TransitionalWithCtxStub struct {
	Impl TransitionalWithCtx
}

func (s_ *TransitionalWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case TransitionalRequestOrdinal:
		in_ := &transitionalWithCtxRequestRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		y, err_ := s_.Impl.Request(args_.Ctx, (*in_).X)
		out_ := &transitionalWithCtxRequestResponse{Y: y}
		return out_, true, err_
	case TransitionalOneWayOrdinal:
		in_ := &transitionalWithCtxOneWayRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.OneWay(args_.Ctx, (*in_).X)
		return nil, false, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type TransitionalEventProxy _bindings.ChannelProxy

func (p *TransitionalEventProxy) Event(x int64) error {
	event_ := &transitionalWithCtxEventResponse{X: x}
	return ((*_bindings.ChannelProxy)(p)).Send(TransitionalEventOrdinal, event_)
}

const (
	WithAndWithoutRequestResponseNoRequestNoResponseOrdinal      uint64 = 0x4b212a6c8c5f7bab
	WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal   uint64 = 0x16a329d17f458668
	WithAndWithoutRequestResponseNoRequestWithResponseOrdinal    uint64 = 0x7d6b2fcf0e2a65bd
	WithAndWithoutRequestResponseWithRequestNoResponseOrdinal    uint64 = 0x65ab625138c50a77
	WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal uint64 = 0x27ee4d2bd405df5f
	WithAndWithoutRequestResponseWithRequestWithResponseOrdinal  uint64 = 0x590e91945d58f5b1
	WithAndWithoutRequestResponseOnEmptyResponseOrdinal          uint64 = 0x4ae85a2b8d7c2e56
	WithAndWithoutRequestResponseOnWithResponseOrdinal           uint64 = 0x50a6f21a322f31a8
)

type WithAndWithoutRequestResponseWithCtxInterface _bindings.ChannelProxy

func (p *WithAndWithoutRequestResponseWithCtxInterface) NoRequestNoResponse(ctx_ _bindings.Context) error {
	var req_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseNoRequestNoResponseOrdinal, req_)
	return err_
}

func (p *WithAndWithoutRequestResponseWithCtxInterface) NoRequestEmptyResponse(ctx_ _bindings.Context) error {
	var req_ _bindings.Message
	var resp_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal, req_, resp_)
	return err_
}

func (p *WithAndWithoutRequestResponseWithCtxInterface) NoRequestWithResponse(ctx_ _bindings.Context) (string, error) {
	var req_ _bindings.Message
	resp_ := &withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithAndWithoutRequestResponseNoRequestWithResponseOrdinal, req_, resp_)
	return (*resp_).Ret, err_
}

func (p *WithAndWithoutRequestResponseWithCtxInterface) WithRequestNoResponse(ctx_ _bindings.Context, arg string) error {
	req_ := &withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest{Arg: arg}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseWithRequestNoResponseOrdinal, req_)
	return err_
}

func (p *WithAndWithoutRequestResponseWithCtxInterface) WithRequestEmptyResponse(ctx_ _bindings.Context, arg string) error {
	req_ := &withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest{Arg: arg}
	var resp_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal, req_, resp_)
	return err_
}

func (p *WithAndWithoutRequestResponseWithCtxInterface) WithRequestWithResponse(ctx_ _bindings.Context, arg string) (string, error) {
	req_ := &withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest{Arg: arg}
	resp_ := &withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithAndWithoutRequestResponseWithRequestWithResponseOrdinal, req_, resp_)
	return (*resp_).Ret, err_
}

func (p *WithAndWithoutRequestResponseWithCtxInterface) ExpectOnEmptyResponse(ctx_ _bindings.Context) error {
	var resp_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(WithAndWithoutRequestResponseOnEmptyResponseOrdinal, resp_)
	return err_
}

func (p *WithAndWithoutRequestResponseWithCtxInterface) ExpectOnWithResponse(ctx_ _bindings.Context) (string, error) {
	resp_ := &withAndWithoutRequestResponseWithCtxOnWithResponseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(WithAndWithoutRequestResponseOnWithResponseOrdinal, resp_)
	return (*resp_).Ret, err_
}

type WithAndWithoutRequestResponseWithCtx interface {
	NoRequestNoResponse(ctx_ _bindings.Context) error
	NoRequestEmptyResponse(ctx_ _bindings.Context) error
	NoRequestWithResponse(ctx_ _bindings.Context) (string, error)
	WithRequestNoResponse(ctx_ _bindings.Context, arg string) error
	WithRequestEmptyResponse(ctx_ _bindings.Context, arg string) error
	WithRequestWithResponse(ctx_ _bindings.Context, arg string) (string, error)
}

type WithAndWithoutRequestResponseWithCtxTransitionalBase struct{}

type WithAndWithoutRequestResponseWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewWithAndWithoutRequestResponseWithCtxInterfaceRequest() (WithAndWithoutRequestResponseWithCtxInterfaceRequest, *WithAndWithoutRequestResponseWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return WithAndWithoutRequestResponseWithCtxInterfaceRequest(req), (*WithAndWithoutRequestResponseWithCtxInterface)(cli), err
}

type WithAndWithoutRequestResponseWithCtxStub struct {
	Impl WithAndWithoutRequestResponseWithCtx
}

func (s_ *WithAndWithoutRequestResponseWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case WithAndWithoutRequestResponseNoRequestNoResponseOrdinal:
		err_ := s_.Impl.NoRequestNoResponse(args_.Ctx)
		return nil, false, err_
	case WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal:
		err_ := s_.Impl.NoRequestEmptyResponse(args_.Ctx)
		return nil, true, err_
	case WithAndWithoutRequestResponseNoRequestWithResponseOrdinal:
		ret, err_ := s_.Impl.NoRequestWithResponse(args_.Ctx)
		out_ := &withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse{Ret: ret}
		return out_, true, err_
	case WithAndWithoutRequestResponseWithRequestNoResponseOrdinal:
		in_ := &withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.WithRequestNoResponse(args_.Ctx, (*in_).Arg)
		return nil, false, err_
	case WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal:
		in_ := &withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		err_ := s_.Impl.WithRequestEmptyResponse(args_.Ctx, (*in_).Arg)
		return nil, true, err_
	case WithAndWithoutRequestResponseWithRequestWithResponseOrdinal:
		in_ := &withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		ret, err_ := s_.Impl.WithRequestWithResponse(args_.Ctx, (*in_).Arg)
		out_ := &withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse{Ret: ret}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type WithAndWithoutRequestResponseEventProxy _bindings.ChannelProxy

func (p *WithAndWithoutRequestResponseEventProxy) OnEmptyResponse() error {
	var event_ _bindings.Message
	return ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseOnEmptyResponseOrdinal, event_)
}
func (p *WithAndWithoutRequestResponseEventProxy) OnWithResponse(ret string) error {
	event_ := &withAndWithoutRequestResponseWithCtxOnWithResponseResponse{Ret: ret}
	return ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseOnWithResponseOrdinal, event_)
}

const (
	WithErrorSyntaxResponseAsStructOrdinal uint64 = 0x3b902a6d8d24693
	WithErrorSyntaxErrorAsPrimitiveOrdinal uint64 = 0x602fd6bd920135e7
	WithErrorSyntaxErrorAsEnumOrdinal      uint64 = 0x4c371e1673212f43
	WithErrorSyntaxHandleInResultOrdinal   uint64 = 0x13092c5b835b0cbf
)

type WithErrorSyntaxWithCtxInterface _bindings.ChannelProxy

func (p *WithErrorSyntaxWithCtxInterface) ResponseAsStruct(ctx_ _bindings.Context) (WithErrorSyntaxResponseAsStructResult, error) {
	var req_ _bindings.Message
	resp_ := &withErrorSyntaxWithCtxResponseAsStructResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxResponseAsStructOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *WithErrorSyntaxWithCtxInterface) ErrorAsPrimitive(ctx_ _bindings.Context) (WithErrorSyntaxErrorAsPrimitiveResult, error) {
	var req_ _bindings.Message
	resp_ := &withErrorSyntaxWithCtxErrorAsPrimitiveResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxErrorAsPrimitiveOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *WithErrorSyntaxWithCtxInterface) ErrorAsEnum(ctx_ _bindings.Context) (WithErrorSyntaxErrorAsEnumResult, error) {
	var req_ _bindings.Message
	resp_ := &withErrorSyntaxWithCtxErrorAsEnumResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxErrorAsEnumOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *WithErrorSyntaxWithCtxInterface) HandleInResult(ctx_ _bindings.Context) (WithErrorSyntaxHandleInResultResult, error) {
	var req_ _bindings.Message
	resp_ := &withErrorSyntaxWithCtxHandleInResultResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxHandleInResultOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

type WithErrorSyntaxWithCtx interface {
	ResponseAsStruct(ctx_ _bindings.Context) (WithErrorSyntaxResponseAsStructResult, error)
	ErrorAsPrimitive(ctx_ _bindings.Context) (WithErrorSyntaxErrorAsPrimitiveResult, error)
	ErrorAsEnum(ctx_ _bindings.Context) (WithErrorSyntaxErrorAsEnumResult, error)
	HandleInResult(ctx_ _bindings.Context) (WithErrorSyntaxHandleInResultResult, error)
}

type WithErrorSyntaxWithCtxTransitionalBase struct{}

type WithErrorSyntaxWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewWithErrorSyntaxWithCtxInterfaceRequest() (WithErrorSyntaxWithCtxInterfaceRequest, *WithErrorSyntaxWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return WithErrorSyntaxWithCtxInterfaceRequest(req), (*WithErrorSyntaxWithCtxInterface)(cli), err
}

type WithErrorSyntaxWithCtxStub struct {
	Impl WithErrorSyntaxWithCtx
}

func (s_ *WithErrorSyntaxWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case WithErrorSyntaxResponseAsStructOrdinal:
		result, err_ := s_.Impl.ResponseAsStruct(args_.Ctx)
		out_ := &withErrorSyntaxWithCtxResponseAsStructResponse{Result: result}
		return out_, true, err_
	case WithErrorSyntaxErrorAsPrimitiveOrdinal:
		result, err_ := s_.Impl.ErrorAsPrimitive(args_.Ctx)
		out_ := &withErrorSyntaxWithCtxErrorAsPrimitiveResponse{Result: result}
		return out_, true, err_
	case WithErrorSyntaxErrorAsEnumOrdinal:
		result, err_ := s_.Impl.ErrorAsEnum(args_.Ctx)
		out_ := &withErrorSyntaxWithCtxErrorAsEnumResponse{Result: result}
		return out_, true, err_
	case WithErrorSyntaxHandleInResultOrdinal:
		result, err_ := s_.Impl.HandleInResult(args_.Ctx)
		out_ := &withErrorSyntaxWithCtxHandleInResultResponse{Result: result}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type WithErrorSyntaxEventProxy _bindings.ChannelProxy

const (
	WithProtocolEndsClientEndsOrdinal           uint64 = 0x51780563edb15042
	WithProtocolEndsServerEndsOrdinal           uint64 = 0x70a02c2ba2228a33
	WithProtocolEndsStructContainingEndsOrdinal uint64 = 0x3893f0baad26f5d5
)

type WithProtocolEndsWithCtxInterface _bindings.ChannelProxy

func (p *WithProtocolEndsWithCtxInterface) ClientEnds(ctx_ _bindings.Context, in DiscoverableProtocolWithCtxInterface) (DiscoverableProtocolWithCtxInterface, error) {
	req_ := &withProtocolEndsWithCtxClientEndsRequest{In: in}
	resp_ := &withProtocolEndsWithCtxClientEndsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithProtocolEndsClientEndsOrdinal, req_, resp_)
	return (*resp_).Out, err_
}

func (p *WithProtocolEndsWithCtxInterface) ServerEnds(ctx_ _bindings.Context, in DiscoverableProtocolWithCtxInterfaceRequest) (DiscoverableProtocolWithCtxInterfaceRequest, error) {
	req_ := &withProtocolEndsWithCtxServerEndsRequest{In: in}
	resp_ := &withProtocolEndsWithCtxServerEndsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithProtocolEndsServerEndsOrdinal, req_, resp_)
	return (*resp_).Out, err_
}

func (p *WithProtocolEndsWithCtxInterface) StructContainingEnds(ctx_ _bindings.Context, in ProtocolEnds) (ProtocolEnds, error) {
	req_ := &withProtocolEndsWithCtxStructContainingEndsRequest{In: in}
	resp_ := &withProtocolEndsWithCtxStructContainingEndsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithProtocolEndsStructContainingEndsOrdinal, req_, resp_)
	return (*resp_).Out, err_
}

type WithProtocolEndsWithCtx interface {
	ClientEnds(ctx_ _bindings.Context, in DiscoverableProtocolWithCtxInterface) (DiscoverableProtocolWithCtxInterface, error)
	ServerEnds(ctx_ _bindings.Context, in DiscoverableProtocolWithCtxInterfaceRequest) (DiscoverableProtocolWithCtxInterfaceRequest, error)
	StructContainingEnds(ctx_ _bindings.Context, in ProtocolEnds) (ProtocolEnds, error)
}

type WithProtocolEndsWithCtxTransitionalBase struct{}

type WithProtocolEndsWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewWithProtocolEndsWithCtxInterfaceRequest() (WithProtocolEndsWithCtxInterfaceRequest, *WithProtocolEndsWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return WithProtocolEndsWithCtxInterfaceRequest(req), (*WithProtocolEndsWithCtxInterface)(cli), err
}

type WithProtocolEndsWithCtxStub struct {
	Impl WithProtocolEndsWithCtx
}

func (s_ *WithProtocolEndsWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case WithProtocolEndsClientEndsOrdinal:
		in_ := &withProtocolEndsWithCtxClientEndsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		out, err_ := s_.Impl.ClientEnds(args_.Ctx, (*in_).In)
		out_ := &withProtocolEndsWithCtxClientEndsResponse{Out: out}
		return out_, true, err_
	case WithProtocolEndsServerEndsOrdinal:
		in_ := &withProtocolEndsWithCtxServerEndsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		out, err_ := s_.Impl.ServerEnds(args_.Ctx, (*in_).In)
		out_ := &withProtocolEndsWithCtxServerEndsResponse{Out: out}
		return out_, true, err_
	case WithProtocolEndsStructContainingEndsOrdinal:
		in_ := &withProtocolEndsWithCtxStructContainingEndsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil {
			return nil, false, err_
		}
		out, err_ := s_.Impl.StructContainingEnds(args_.Ctx, (*in_).In)
		out_ := &withProtocolEndsWithCtxStructContainingEndsResponse{Out: out}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type WithProtocolEndsEventProxy _bindings.ChannelProxy