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 = ObjType(0)

type ObjType uint32

const (
	ObjTypeNone   ObjType = 0
	ObjTypeSocket ObjType = 14
)

func (_ ObjType) I_EnumValues() []ObjType {
	return []ObjType{
		ObjTypeNone,
		ObjTypeSocket,
	}
}

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

func (x ObjType) IsUnknown() bool {
	switch x {
	case 0:
		return true
	case 14:
		return true
	default:
		return false
	}
}

func (x ObjType) String() string {
	switch x {
	case 0:
		return "None"
	case 14:
		return "Socket"
	}
	return "Unknown"
}

var _ _bindings.Enum = ErrorEnun(0)

type ErrorEnun uint32

const (
	ErrorEnunErrFoo ErrorEnun = 1
	ErrorEnunErrBar ErrorEnun = 2
)

func (_ ErrorEnun) I_EnumValues() []ErrorEnun {
	return []ErrorEnun{
		ErrorEnunErrFoo,
		ErrorEnunErrBar,
	}
}

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

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

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

type WithErrorSyntaxResponseAsStructResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	A int64    `fidl_offset_v1:"0"`
	B int64    `fidl_offset_v1:"8"`
	C int64    `fidl_offset_v1:"16"`
}

var _mWithErrorSyntaxResponseAsStructResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxResponseAsStructResponse{})

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

type WithErrorSyntaxErrorAsPrimitiveResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mWithErrorSyntaxErrorAsPrimitiveResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsPrimitiveResponse{})

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

type WithErrorSyntaxErrorAsEnumResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
}

var _mWithErrorSyntaxErrorAsEnumResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsEnumResponse{})

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

type withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse struct {
	_   struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Ret string   `fidl_offset_v1:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse{})

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

type withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest struct {
	_   struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Arg string   `fidl_offset_v1:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest{})

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

type withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest struct {
	_   struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Arg string   `fidl_offset_v1:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest{})

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

type withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest struct {
	_   struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Arg string   `fidl_offset_v1:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest{})

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

type withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse struct {
	_   struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Ret string   `fidl_offset_v1:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse{})

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

type withAndWithoutRequestResponseWithCtxOnWithResponseResponse struct {
	_   struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Ret string   `fidl_offset_v1:"0" fidl_bounds:""`
}

var _mwithAndWithoutRequestResponseWithCtxOnWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxOnWithResponseResponse{})

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

type withErrorSyntaxWithCtxResponseAsStructResponse struct {
	_      struct{}                              `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result WithErrorSyntaxResponseAsStructResult `fidl_offset_v1:"0"`
}

var _mwithErrorSyntaxWithCtxResponseAsStructResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxWithCtxResponseAsStructResponse{})

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

type withErrorSyntaxWithCtxErrorAsPrimitiveResponse struct {
	_      struct{}                              `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result WithErrorSyntaxErrorAsPrimitiveResult `fidl_offset_v1:"0"`
}

var _mwithErrorSyntaxWithCtxErrorAsPrimitiveResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxWithCtxErrorAsPrimitiveResponse{})

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

type withErrorSyntaxWithCtxErrorAsEnumResponse struct {
	_      struct{}                         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Result WithErrorSyntaxErrorAsEnumResult `fidl_offset_v1:"0"`
}

var _mwithErrorSyntaxWithCtxErrorAsEnumResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxWithCtxErrorAsEnumResponse{})

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

type channelProtocolWithCtxMethodARequest struct {
	_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	A int64    `fidl_offset_v1:"0"`
	B int64    `fidl_offset_v1:"8"`
}

var _mchannelProtocolWithCtxMethodARequest = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMethodARequest{})

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

type channelProtocolWithCtxEventAResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	A int64    `fidl_offset_v1:"0"`
	B int64    `fidl_offset_v1:"8"`
}

var _mchannelProtocolWithCtxEventAResponse = _bindings.CreateLazyMarshaler(channelProtocolWithCtxEventAResponse{})

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

type channelProtocolWithCtxMethodBRequest struct {
	_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	A int64    `fidl_offset_v1:"0"`
	B int64    `fidl_offset_v1:"8"`
}

var _mchannelProtocolWithCtxMethodBRequest = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMethodBRequest{})

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

type channelProtocolWithCtxMethodBResponse struct {
	_      struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Result int64    `fidl_offset_v1:"0"`
}

var _mchannelProtocolWithCtxMethodBResponse = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMethodBResponse{})

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

type channelProtocolWithCtxTakeHandleRequest struct {
	_ struct{}   `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	H _zx.Handle `fidl_offset_v1:"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_v1:"8" fidl_alignment_v1:"8"`
	A _zx.Socket `fidl_offset_v1:"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_v1:"8" fidl_alignment_v1:"8"`
	B _zx.Socket `fidl_offset_v1:"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 transitionalWithCtxRequestRequest struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	X int64    `fidl_offset_v1:"0"`
}

var _mtransitionalWithCtxRequestRequest = _bindings.CreateLazyMarshaler(transitionalWithCtxRequestRequest{})

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

type transitionalWithCtxRequestResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Y int64    `fidl_offset_v1:"0"`
}

var _mtransitionalWithCtxRequestResponse = _bindings.CreateLazyMarshaler(transitionalWithCtxRequestResponse{})

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

type transitionalWithCtxOneWayRequest struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	X int64    `fidl_offset_v1:"0"`
}

var _mtransitionalWithCtxOneWayRequest = _bindings.CreateLazyMarshaler(transitionalWithCtxOneWayRequest{})

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

type transitionalWithCtxEventResponse struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	X int64    `fidl_offset_v1:"0"`
}

var _mtransitionalWithCtxEventResponse = _bindings.CreateLazyMarshaler(transitionalWithCtxEventResponse{})

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

type I_withErrorSyntaxResponseAsStructResultTag uint64

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

type WithErrorSyntaxResponseAsStructResult struct {
	I_withErrorSyntaxResponseAsStructResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	Response                                   WithErrorSyntaxResponseAsStructResponse `fidl_ordinal:"1"`
	Err                                        uint32                                  `fidl_ordinal:"2"`
}

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
}

type I_withErrorSyntaxErrorAsPrimitiveResultTag uint64

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

type WithErrorSyntaxErrorAsPrimitiveResult struct {
	I_withErrorSyntaxErrorAsPrimitiveResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	Response                                   WithErrorSyntaxErrorAsPrimitiveResponse `fidl_ordinal:"1"`
	Err                                        uint32                                  `fidl_ordinal:"2"`
}

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_withErrorSyntaxErrorAsEnumResultTag uint64

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

type WithErrorSyntaxErrorAsEnumResult struct {
	I_withErrorSyntaxErrorAsEnumResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	Response                              WithErrorSyntaxErrorAsEnumResponse `fidl_ordinal:"1"`
	Err                                   ErrorEnun                          `fidl_ordinal:"2"`
}

func (_m *WithErrorSyntaxErrorAsEnumResult) reset() {
	switch _m.I_withErrorSyntaxErrorAsEnumResultTag {
	case 1:
		var _zeroed WithErrorSyntaxErrorAsEnumResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed ErrorEnun
		_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 ErrorEnun) {
	_m.reset()
	_m.I_withErrorSyntaxErrorAsEnumResultTag = WithErrorSyntaxErrorAsEnumResultErr
	_m.Err = err
}

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

const (
	WithAndWithoutRequestResponseNoRequestNoResponseOrdinal      uint64 = 0x6ad894147d0c6ba4
	WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal   uint64 = 0x4068f26bf6d868ae
	WithAndWithoutRequestResponseNoRequestWithResponseOrdinal    uint64 = 0x447e655905ccfbf4
	WithAndWithoutRequestResponseWithRequestNoResponseOrdinal    uint64 = 0x7cb47b2f9e76d17d
	WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal uint64 = 0x65eb512ff0e1c07e
	WithAndWithoutRequestResponseWithRequestWithResponseOrdinal  uint64 = 0x1d323510d4447cf1
	WithAndWithoutRequestResponseOnEmptyResponseOrdinal          uint64 = 0x125c87a592bff029
	WithAndWithoutRequestResponseOnWithResponseOrdinal           uint64 = 0x177adc0a3ee346c2
)

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{}
		out_.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.UnmarshalWithContext2(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.UnmarshalWithContext2(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.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		ret, err_ := s_.Impl.WithRequestWithResponse(args_.Ctx, in_.Arg)
		out_ := withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse{}
		out_.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 = 0x3784d38864674290
	WithErrorSyntaxErrorAsPrimitiveOrdinal uint64 = 0x2f7c390f3cdef4ce
	WithErrorSyntaxErrorAsEnumOrdinal      uint64 = 0x8b550d7c29f740c
)

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

type WithErrorSyntaxWithCtx interface {
	ResponseAsStruct(ctx_ _bindings.Context) (WithErrorSyntaxResponseAsStructResult, error)
	ErrorAsPrimitive(ctx_ _bindings.Context) (WithErrorSyntaxErrorAsPrimitiveResult, error)
	ErrorAsEnum(ctx_ _bindings.Context) (WithErrorSyntaxErrorAsEnumResult, 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{}
		out_.Result = result
		return &out_, true, err_
	case WithErrorSyntaxErrorAsPrimitiveOrdinal:
		result, err_ := s_.Impl.ErrorAsPrimitive(args_.Ctx)
		out_ := withErrorSyntaxWithCtxErrorAsPrimitiveResponse{}
		out_.Result = result
		return &out_, true, err_
	case WithErrorSyntaxErrorAsEnumOrdinal:
		result, err_ := s_.Impl.ErrorAsEnum(args_.Ctx)
		out_ := withErrorSyntaxWithCtxErrorAsEnumResponse{}
		out_.Result = result
		return &out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type WithErrorSyntaxEventProxy _bindings.ChannelProxy

const (
	ChannelProtocolMethodAOrdinal      uint64 = 0x7d92c10fb2d002e
	ChannelProtocolEventAOrdinal       uint64 = 0x52c2fa481a687dfa
	ChannelProtocolMethodBOrdinal      uint64 = 0x5da1d2ed00055cea
	ChannelProtocolTakeHandleOrdinal   uint64 = 0xc25674355065c28
	ChannelProtocolMutateSocketOrdinal uint64 = 0x7dd036a18b33b76a
)

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.UnmarshalWithContext2(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.UnmarshalWithContext2(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{}
		out_.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.UnmarshalWithContext2(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.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		b, err_ := s_.Impl.MutateSocket(args_.Ctx, in_.A)
		out_ := channelProtocolWithCtxMutateSocketResponse{}
		out_.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 (
	TransitionalRequestOrdinal uint64 = 0x62d345e621780ee8
	TransitionalOneWayOrdinal  uint64 = 0xf99bc4b26bc9ea5
	TransitionalEventOrdinal   uint64 = 0x53bb9212bcbe8966
)

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.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		y, err_ := s_.Impl.Request(args_.Ctx, in_.X)
		out_ := transitionalWithCtxRequestResponse{}
		out_.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.UnmarshalWithContext2(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 (
	DiscoverableProtocolMethodOrdinal uint64 = 0x39790af74e0167
)

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 "fidl.test.protocols.DiscoverableProtocol"
}
func (c DiscoverableProtocolWithCtxInterfaceRequest) ToChannel() _zx.Channel {
	return c.Channel
}

const DiscoverableProtocolName = "fidl.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