garnet/go/src/fidl/compiler/backend/goldens/protocols.test.json.go.golden

// Code generated by fidlgen; DO NOT EDIT.

package name

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

type ErrorEnun uint32

const (
	ErrorEnunErrFoo ErrorEnun = 1
	ErrorEnunErrBar ErrorEnun = 2
)

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 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 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"`
	Response                                   WithErrorSyntaxResponseAsStructResponse `fidl_ordinal:"1"`
	Err                                        uint32                                  `fidl_ordinal:"2"`
}

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.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.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"`
	Response                                   WithErrorSyntaxErrorAsPrimitiveResponse `fidl_ordinal:"1"`
	Err                                        uint32                                  `fidl_ordinal:"2"`
}

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.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.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"`
	Response                              WithErrorSyntaxErrorAsEnumResponse `fidl_ordinal:"1"`
	Err                                   ErrorEnun                          `fidl_ordinal:"2"`
}

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.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.I_withErrorSyntaxErrorAsEnumResultTag = WithErrorSyntaxErrorAsEnumResultErr
	_m.Err = err
}

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

const (
	WithAndWithoutRequestResponseNoRequestNoResponseOrdinal         uint64 = 0x1e03f87500000000
	WithAndWithoutRequestResponseNoRequestNoResponseGenOrdinal      uint64 = 0x3931f96bc77fba8
	WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal      uint64 = 0x4df6dbd500000000
	WithAndWithoutRequestResponseNoRequestEmptyResponseGenOrdinal   uint64 = 0x706ec7bd335005f9
	WithAndWithoutRequestResponseNoRequestWithResponseOrdinal       uint64 = 0x668d7f800000000
	WithAndWithoutRequestResponseNoRequestWithResponseGenOrdinal    uint64 = 0x4625ad5934067a48
	WithAndWithoutRequestResponseWithRequestNoResponseOrdinal       uint64 = 0x19c2137100000000
	WithAndWithoutRequestResponseWithRequestNoResponseGenOrdinal    uint64 = 0x46e5095902913025
	WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal    uint64 = 0x76f2397300000000
	WithAndWithoutRequestResponseWithRequestEmptyResponseGenOrdinal uint64 = 0x180c481d4a15967
	WithAndWithoutRequestResponseWithRequestWithResponseOrdinal     uint64 = 0x1973292000000000
	WithAndWithoutRequestResponseWithRequestWithResponseGenOrdinal  uint64 = 0x553860267eceec0
	WithAndWithoutRequestResponseOnEmptyResponseOrdinal             uint64 = 0x697fd73200000000
	WithAndWithoutRequestResponseOnEmptyResponseGenOrdinal          uint64 = 0x42e90e9a86944b3
	WithAndWithoutRequestResponseOnWithResponseOrdinal              uint64 = 0x7a47120700000000
	WithAndWithoutRequestResponseOnWithResponseGenOrdinal           uint64 = 0x2a9767b3ae6c2b09
)

type WithAndWithoutRequestResponseWithCtxInterface _bindings.ChannelProxy

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

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

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

func (p *WithAndWithoutRequestResponseWithCtxInterface) WithRequestNoResponse(ctx_ _bindings.Context, arg string) error {
	req_ := &withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest{
		Arg: arg,
	}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseWithRequestNoResponseGenOrdinal, 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(WithAndWithoutRequestResponseWithRequestEmptyResponseGenOrdinal, req_, resp_, WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal, WithAndWithoutRequestResponseWithRequestEmptyResponseGenOrdinal)
	return err_
}

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

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

func (p *WithAndWithoutRequestResponseWithCtxInterface) ExpectOnWithResponse(ctx_ _bindings.Context) (string, error) {
	resp_ := &withAndWithoutRequestResponseWithCtxOnWithResponseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(WithAndWithoutRequestResponseOnWithResponseOrdinal, resp_, WithAndWithoutRequestResponseOnWithResponseGenOrdinal)
	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:
		fallthrough
	case WithAndWithoutRequestResponseNoRequestNoResponseGenOrdinal:
		err_ := s_.Impl.NoRequestNoResponse(args_.Ctx)
		return nil, false, err_
	case WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal:
		fallthrough
	case WithAndWithoutRequestResponseNoRequestEmptyResponseGenOrdinal:
		err_ := s_.Impl.NoRequestEmptyResponse(args_.Ctx)
		return nil, true, err_
	case WithAndWithoutRequestResponseNoRequestWithResponseOrdinal:
		fallthrough
	case WithAndWithoutRequestResponseNoRequestWithResponseGenOrdinal:
		ret, err_ := s_.Impl.NoRequestWithResponse(args_.Ctx)
		out_ := withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse{}
		out_.Ret = ret
		return &out_, true, err_
	case WithAndWithoutRequestResponseWithRequestNoResponseOrdinal:
		fallthrough
	case WithAndWithoutRequestResponseWithRequestNoResponseGenOrdinal:
		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:
		fallthrough
	case WithAndWithoutRequestResponseWithRequestEmptyResponseGenOrdinal:
		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:
		fallthrough
	case WithAndWithoutRequestResponseWithRequestWithResponseGenOrdinal:
		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 WithAndWithoutRequestResponseService struct {
	_bindings.BindingSet
}

func (s *WithAndWithoutRequestResponseService) EventProxyFor(key _bindings.BindingKey) (*WithAndWithoutRequestResponseEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*WithAndWithoutRequestResponseEventProxy)(pxy), err
}

type WithAndWithoutRequestResponseEventProxy _bindings.ChannelProxy

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

const (
	WithErrorSyntaxResponseAsStructOrdinal    uint64 = 0x4f3c32be00000000
	WithErrorSyntaxResponseAsStructGenOrdinal uint64 = 0x592157d505db2bcf
	WithErrorSyntaxErrorAsPrimitiveOrdinal    uint64 = 0x7b58113900000000
	WithErrorSyntaxErrorAsPrimitiveGenOrdinal uint64 = 0x20cf80ad7d9b60be
	WithErrorSyntaxErrorAsEnumOrdinal         uint64 = 0x4c95de1f00000000
	WithErrorSyntaxErrorAsEnumGenOrdinal      uint64 = 0x3fcd36560f812e7f
)

type WithErrorSyntaxWithCtxInterface _bindings.ChannelProxy

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

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

func (p *WithErrorSyntaxWithCtxInterface) ErrorAsEnum(ctx_ _bindings.Context) (WithErrorSyntaxErrorAsEnumResult, error) {
	var req_ _bindings.Message
	resp_ := &withErrorSyntaxWithCtxErrorAsEnumResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxErrorAsEnumGenOrdinal, req_, resp_, WithErrorSyntaxErrorAsEnumOrdinal, WithErrorSyntaxErrorAsEnumGenOrdinal)
	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:
		fallthrough
	case WithErrorSyntaxResponseAsStructGenOrdinal:
		result, err_ := s_.Impl.ResponseAsStruct(args_.Ctx)
		out_ := withErrorSyntaxWithCtxResponseAsStructResponse{}
		out_.Result = result
		return &out_, true, err_
	case WithErrorSyntaxErrorAsPrimitiveOrdinal:
		fallthrough
	case WithErrorSyntaxErrorAsPrimitiveGenOrdinal:
		result, err_ := s_.Impl.ErrorAsPrimitive(args_.Ctx)
		out_ := withErrorSyntaxWithCtxErrorAsPrimitiveResponse{}
		out_.Result = result
		return &out_, true, err_
	case WithErrorSyntaxErrorAsEnumOrdinal:
		fallthrough
	case WithErrorSyntaxErrorAsEnumGenOrdinal:
		result, err_ := s_.Impl.ErrorAsEnum(args_.Ctx)
		out_ := withErrorSyntaxWithCtxErrorAsEnumResponse{}
		out_.Result = result
		return &out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type WithErrorSyntaxService struct {
	_bindings.BindingSet
}

func (s *WithErrorSyntaxService) EventProxyFor(key _bindings.BindingKey) (*WithErrorSyntaxEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*WithErrorSyntaxEventProxy)(pxy), err
}

type WithErrorSyntaxEventProxy _bindings.ChannelProxy

const (
	ChannelProtocolMethodAOrdinal         uint64 = 0x556693d200000000
	ChannelProtocolMethodAGenOrdinal      uint64 = 0x1b1e059b3f02bffc
	ChannelProtocolEventAOrdinal          uint64 = 0x1c78c20200000000
	ChannelProtocolEventAGenOrdinal       uint64 = 0x2558b206a254d8a0
	ChannelProtocolMethodBOrdinal         uint64 = 0xac6551b00000000
	ChannelProtocolMethodBGenOrdinal      uint64 = 0x5db17a61464744a3
	ChannelProtocolMutateSocketOrdinal    uint64 = 0x4b02e28600000000
	ChannelProtocolMutateSocketGenOrdinal uint64 = 0x36caa6fff7569577
)

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(ChannelProtocolMethodAGenOrdinal, req_)
	return err_
}

func (p *ChannelProtocolWithCtxInterface) ExpectEventA(ctx_ _bindings.Context) (int64, int64, error) {
	resp_ := &channelProtocolWithCtxEventAResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(ChannelProtocolEventAOrdinal, resp_, ChannelProtocolEventAGenOrdinal)
	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(ChannelProtocolMethodBGenOrdinal, req_, resp_, ChannelProtocolMethodBOrdinal, ChannelProtocolMethodBGenOrdinal)
	return resp_.Result, 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(ChannelProtocolMutateSocketGenOrdinal, req_, resp_, ChannelProtocolMutateSocketOrdinal, ChannelProtocolMutateSocketGenOrdinal)
	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)
	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:
		fallthrough
	case ChannelProtocolMethodAGenOrdinal:
		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:
		fallthrough
	case ChannelProtocolMethodBGenOrdinal:
		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 ChannelProtocolMutateSocketOrdinal:
		fallthrough
	case ChannelProtocolMutateSocketGenOrdinal:
		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 ChannelProtocolService struct {
	_bindings.BindingSet
}

func (s *ChannelProtocolService) EventProxyFor(key _bindings.BindingKey) (*ChannelProtocolEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*ChannelProtocolEventProxy)(pxy), err
}

type ChannelProtocolEventProxy _bindings.ChannelProxy

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