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

// WARNING: This file is machine generated by fidlgen.

// fidl_experiment = output_index_json

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 ChannelProtocolEventARequest 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 _mChannelProtocolEventARequest = _bindings.CreateLazyMarshaler(ChannelProtocolEventARequest{})

func (msg *ChannelProtocolEventARequest) Marshaler() _bindings.Marshaler {
	return _mChannelProtocolEventARequest
}

type ChannelProtocolMethodARequest 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 _mChannelProtocolMethodARequest = _bindings.CreateLazyMarshaler(ChannelProtocolMethodARequest{})

func (msg *ChannelProtocolMethodARequest) Marshaler() _bindings.Marshaler {
	return _mChannelProtocolMethodARequest
}

type ChannelProtocolMethodBRequest 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 _mChannelProtocolMethodBRequest = _bindings.CreateLazyMarshaler(ChannelProtocolMethodBRequest{})

func (msg *ChannelProtocolMethodBRequest) Marshaler() _bindings.Marshaler {
	return _mChannelProtocolMethodBRequest
}

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

var _mChannelProtocolMethodBResponse = _bindings.CreateLazyMarshaler(ChannelProtocolMethodBResponse{})

func (msg *ChannelProtocolMethodBResponse) Marshaler() _bindings.Marshaler {
	return _mChannelProtocolMethodBResponse
}

type ChannelProtocolMutateSocketRequest 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 _mChannelProtocolMutateSocketRequest = _bindings.CreateLazyMarshaler(ChannelProtocolMutateSocketRequest{})

func (msg *ChannelProtocolMutateSocketRequest) Marshaler() _bindings.Marshaler {
	return _mChannelProtocolMutateSocketRequest
}

type ChannelProtocolMutateSocketResponse 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 _mChannelProtocolMutateSocketResponse = _bindings.CreateLazyMarshaler(ChannelProtocolMutateSocketResponse{})

func (msg *ChannelProtocolMutateSocketResponse) Marshaler() _bindings.Marshaler {
	return _mChannelProtocolMutateSocketResponse
}

type ChannelProtocolTakeHandleRequest 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 _mChannelProtocolTakeHandleRequest = _bindings.CreateLazyMarshaler(ChannelProtocolTakeHandleRequest{})

func (msg *ChannelProtocolTakeHandleRequest) Marshaler() _bindings.Marshaler {
	return _mChannelProtocolTakeHandleRequest
}

type HandleRightsProtocolAnEventRequest 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 _mHandleRightsProtocolAnEventRequest = _bindings.CreateLazyMarshaler(HandleRightsProtocolAnEventRequest{})

func (msg *HandleRightsProtocolAnEventRequest) Marshaler() _bindings.Marshaler {
	return _mHandleRightsProtocolAnEventRequest
}

type HandleRightsProtocolNoResponseMethodRequest 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 _mHandleRightsProtocolNoResponseMethodRequest = _bindings.CreateLazyMarshaler(HandleRightsProtocolNoResponseMethodRequest{})

func (msg *HandleRightsProtocolNoResponseMethodRequest) Marshaler() _bindings.Marshaler {
	return _mHandleRightsProtocolNoResponseMethodRequest
}

type HandleRightsProtocolResponseMethodRequest 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 _mHandleRightsProtocolResponseMethodRequest = _bindings.CreateLazyMarshaler(HandleRightsProtocolResponseMethodRequest{})

func (msg *HandleRightsProtocolResponseMethodRequest) Marshaler() _bindings.Marshaler {
	return _mHandleRightsProtocolResponseMethodRequest
}

type HandleRightsProtocolResponseMethodResponse 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 _mHandleRightsProtocolResponseMethodResponse = _bindings.CreateLazyMarshaler(HandleRightsProtocolResponseMethodResponse{})

func (msg *HandleRightsProtocolResponseMethodResponse) Marshaler() _bindings.Marshaler {
	return _mHandleRightsProtocolResponseMethodResponse
}

type ManyParametersFifteenRequest 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 _mManyParametersFifteenRequest = _bindings.CreateLazyMarshaler(ManyParametersFifteenRequest{})

func (msg *ManyParametersFifteenRequest) Marshaler() _bindings.Marshaler {
	return _mManyParametersFifteenRequest
}

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

var _mMethodWithUnionUnionMethodRequest = _bindings.CreateLazyMarshaler(MethodWithUnionUnionMethodRequest{})

func (msg *MethodWithUnionUnionMethodRequest) Marshaler() _bindings.Marshaler {
	return _mMethodWithUnionUnionMethodRequest
}

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

var _mMethodWithUnionUnionMethodResponse = _bindings.CreateLazyMarshaler(MethodWithUnionUnionMethodResponse{})

func (msg *MethodWithUnionUnionMethodResponse) Marshaler() _bindings.Marshaler {
	return _mMethodWithUnionUnionMethodResponse
}

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 SyscallProtocolMethodCRequest 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 _mSyscallProtocolMethodCRequest = _bindings.CreateLazyMarshaler(SyscallProtocolMethodCRequest{})

func (msg *SyscallProtocolMethodCRequest) Marshaler() _bindings.Marshaler {
	return _mSyscallProtocolMethodCRequest
}

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

var _mWithAndWithoutRequestResponseNoRequestWithResponseResponse = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseNoRequestWithResponseResponse{})

func (msg *WithAndWithoutRequestResponseNoRequestWithResponseResponse) Marshaler() _bindings.Marshaler {
	return _mWithAndWithoutRequestResponseNoRequestWithResponseResponse
}

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

var _mWithAndWithoutRequestResponseOnWithResponseRequest = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseOnWithResponseRequest{})

func (msg *WithAndWithoutRequestResponseOnWithResponseRequest) Marshaler() _bindings.Marshaler {
	return _mWithAndWithoutRequestResponseOnWithResponseRequest
}

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

var _mWithAndWithoutRequestResponseWithRequestEmptyResponseRequest = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseWithRequestEmptyResponseRequest{})

func (msg *WithAndWithoutRequestResponseWithRequestEmptyResponseRequest) Marshaler() _bindings.Marshaler {
	return _mWithAndWithoutRequestResponseWithRequestEmptyResponseRequest
}

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

var _mWithAndWithoutRequestResponseWithRequestNoResponseRequest = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseWithRequestNoResponseRequest{})

func (msg *WithAndWithoutRequestResponseWithRequestNoResponseRequest) Marshaler() _bindings.Marshaler {
	return _mWithAndWithoutRequestResponseWithRequestNoResponseRequest
}

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

var _mWithAndWithoutRequestResponseWithRequestWithResponseRequest = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseWithRequestWithResponseRequest{})

func (msg *WithAndWithoutRequestResponseWithRequestWithResponseRequest) Marshaler() _bindings.Marshaler {
	return _mWithAndWithoutRequestResponseWithRequestWithResponseRequest
}

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

var _mWithAndWithoutRequestResponseWithRequestWithResponseResponse = _bindings.CreateLazyMarshaler(WithAndWithoutRequestResponseWithRequestWithResponseResponse{})

func (msg *WithAndWithoutRequestResponseWithRequestWithResponseResponse) Marshaler() _bindings.Marshaler {
	return _mWithAndWithoutRequestResponseWithRequestWithResponseResponse
}

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 WithProtocolEndsClientEndsRequest struct {
	_  struct{}                             `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
	In DiscoverableProtocolWithCtxInterface `fidl_offset_v2:"0" fidl_handle_subtype:"4"`
}

var _mWithProtocolEndsClientEndsRequest = _bindings.CreateLazyMarshaler(WithProtocolEndsClientEndsRequest{})

func (msg *WithProtocolEndsClientEndsRequest) Marshaler() _bindings.Marshaler {
	return _mWithProtocolEndsClientEndsRequest
}

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

var _mWithProtocolEndsClientEndsResponse = _bindings.CreateLazyMarshaler(WithProtocolEndsClientEndsResponse{})

func (msg *WithProtocolEndsClientEndsResponse) Marshaler() _bindings.Marshaler {
	return _mWithProtocolEndsClientEndsResponse
}

type WithProtocolEndsServerEndsRequest 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 _mWithProtocolEndsServerEndsRequest = _bindings.CreateLazyMarshaler(WithProtocolEndsServerEndsRequest{})

func (msg *WithProtocolEndsServerEndsRequest) Marshaler() _bindings.Marshaler {
	return _mWithProtocolEndsServerEndsRequest
}

type WithProtocolEndsServerEndsResponse 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 _mWithProtocolEndsServerEndsResponse = _bindings.CreateLazyMarshaler(WithProtocolEndsServerEndsResponse{})

func (msg *WithProtocolEndsServerEndsResponse) Marshaler() _bindings.Marshaler {
	return _mWithProtocolEndsServerEndsResponse
}

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

var _mWithProtocolEndsStructContainingEndsRequest = _bindings.CreateLazyMarshaler(WithProtocolEndsStructContainingEndsRequest{})

func (msg *WithProtocolEndsStructContainingEndsRequest) Marshaler() _bindings.Marshaler {
	return _mWithProtocolEndsStructContainingEndsRequest
}

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

var _mWithProtocolEndsStructContainingEndsResponse = _bindings.CreateLazyMarshaler(WithProtocolEndsStructContainingEndsResponse{})

func (msg *WithProtocolEndsStructContainingEndsResponse) Marshaler() _bindings.Marshaler {
	return _mWithProtocolEndsStructContainingEndsResponse
}

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 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_ := &ChannelProtocolMethodARequest{A: a, B: b}
	err_ := ((*_bindings.ChannelProxy)(p)).Send(ChannelProtocolMethodAOrdinal, req_)
	return err_
}

func (p *ChannelProtocolWithCtxInterface) ExpectEventA(ctx_ _bindings.Context) (int64, int64, error) {
	resp_ := &ChannelProtocolEventARequest{}
	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_ := &ChannelProtocolMethodBRequest{A: a, B: b}
	resp_ := &ChannelProtocolMethodBResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ChannelProtocolMethodBOrdinal, req_, resp_)
	return (*resp_).Result, err_
}

func (p *ChannelProtocolWithCtxInterface) TakeHandle(ctx_ _bindings.Context, h _zx.Handle) error {
	req_ := &ChannelProtocolTakeHandleRequest{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_ := &ChannelProtocolMutateSocketRequest{A: a}
	resp_ := &ChannelProtocolMutateSocketResponse{}
	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 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_ := &ChannelProtocolMethodARequest{}
		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_ := &ChannelProtocolMethodBRequest{}
		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_ := &ChannelProtocolMethodBResponse{Result: result}
		return out_, true, err_
	case ChannelProtocolTakeHandleOrdinal:
		in_ := &ChannelProtocolTakeHandleRequest{}
		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_ := &ChannelProtocolMutateSocketRequest{}
		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_ := &ChannelProtocolMutateSocketResponse{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_ := &ChannelProtocolEventARequest{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 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_ := &HandleRightsProtocolNoResponseMethodRequest{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_ := &HandleRightsProtocolResponseMethodRequest{H: h}
	resp_ := &HandleRightsProtocolResponseMethodResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(HandleRightsProtocolResponseMethodOrdinal, req_, resp_)
	return (*resp_).H, err_
}

func (p *HandleRightsProtocolWithCtxInterface) ExpectAnEvent(ctx_ _bindings.Context) (_zx.Socket, error) {
	resp_ := &HandleRightsProtocolAnEventRequest{}
	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 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_ := &HandleRightsProtocolNoResponseMethodRequest{}
		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_ := &HandleRightsProtocolResponseMethodRequest{}
		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_ := &HandleRightsProtocolResponseMethodResponse{H: h}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type HandleRightsProtocolEventProxy _bindings.ChannelProxy

func (p *HandleRightsProtocolEventProxy) AnEvent(h _zx.Socket) error {
	event_ := &HandleRightsProtocolAnEventRequest{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_ := &ManyParametersFifteenRequest{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 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_ := &ManyParametersFifteenRequest{}
		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_ := &MethodWithUnionUnionMethodRequest{U: u}
	resp_ := &MethodWithUnionUnionMethodResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(MethodWithUnionUnionMethodOrdinal, req_, resp_)
	return (*resp_).U, err_
}

type MethodWithUnionWithCtx interface {
	UnionMethod(ctx_ _bindings.Context, u TheUnion) (*TheUnion, error)
}
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_ := &MethodWithUnionUnionMethodRequest{}
		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_ := &MethodWithUnionUnionMethodResponse{U: u}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type MethodWithUnionEventProxy _bindings.ChannelProxy

const ()

type PlatformServerWithCtxInterface _bindings.ChannelProxy

type PlatformServerWithCtx interface {
}
type PlatformServerWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewPlatformServerWithCtxInterfaceRequest() (PlatformServerWithCtxInterfaceRequest, *PlatformServerWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return PlatformServerWithCtxInterfaceRequest(req), (*PlatformServerWithCtxInterface)(cli), err
}

// Implements ServiceRequest.
func (_ PlatformServerWithCtxInterfaceRequest) Name() string {
	return "platform"
}
func (c PlatformServerWithCtxInterfaceRequest) ToChannel() _zx.Channel {
	return c.Channel
}

const PlatformServerName = "platform"

type PlatformServerWithCtxStub struct {
	Impl PlatformServerWithCtx
}

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

type PlatformServerEventProxy _bindings.ChannelProxy

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_ := &WithAndWithoutRequestResponseNoRequestWithResponseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithAndWithoutRequestResponseNoRequestWithResponseOrdinal, req_, resp_)
	return (*resp_).Ret, err_
}

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

func (p *WithAndWithoutRequestResponseWithCtxInterface) WithRequestEmptyResponse(ctx_ _bindings.Context, arg string) error {
	req_ := &WithAndWithoutRequestResponseWithRequestEmptyResponseRequest{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_ := &WithAndWithoutRequestResponseWithRequestWithResponseRequest{Arg: arg}
	resp_ := &WithAndWithoutRequestResponseWithRequestWithResponseResponse{}
	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_ := &WithAndWithoutRequestResponseOnWithResponseRequest{}
	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 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_ := &WithAndWithoutRequestResponseNoRequestWithResponseResponse{Ret: ret}
		return out_, true, err_
	case WithAndWithoutRequestResponseWithRequestNoResponseOrdinal:
		in_ := &WithAndWithoutRequestResponseWithRequestNoResponseRequest{}
		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_ := &WithAndWithoutRequestResponseWithRequestEmptyResponseRequest{}
		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_ := &WithAndWithoutRequestResponseWithRequestWithResponseRequest{}
		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_ := &WithAndWithoutRequestResponseWithRequestWithResponseResponse{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_ := &WithAndWithoutRequestResponseOnWithResponseRequest{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_ := &WithErrorSyntaxResponseAsStructResult{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxResponseAsStructOrdinal, req_, resp_)
	return (*resp_), err_
}

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

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

func (p *WithErrorSyntaxWithCtxInterface) HandleInResult(ctx_ _bindings.Context) (WithErrorSyntaxHandleInResultResult, error) {
	var req_ _bindings.Message
	resp_ := &WithErrorSyntaxHandleInResultResult{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxHandleInResultOrdinal, req_, resp_)
	return (*resp_), 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 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:
		payload, err_ := s_.Impl.ResponseAsStruct(args_.Ctx)
		out_ := &payload
		return out_, true, err_
	case WithErrorSyntaxErrorAsPrimitiveOrdinal:
		payload, err_ := s_.Impl.ErrorAsPrimitive(args_.Ctx)
		out_ := &payload
		return out_, true, err_
	case WithErrorSyntaxErrorAsEnumOrdinal:
		payload, err_ := s_.Impl.ErrorAsEnum(args_.Ctx)
		out_ := &payload
		return out_, true, err_
	case WithErrorSyntaxHandleInResultOrdinal:
		payload, err_ := s_.Impl.HandleInResult(args_.Ctx)
		out_ := &payload
		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_ := &WithProtocolEndsClientEndsRequest{In: in}
	resp_ := &WithProtocolEndsClientEndsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(WithProtocolEndsClientEndsOrdinal, req_, resp_)
	return (*resp_).Out, err_
}

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

func (p *WithProtocolEndsWithCtxInterface) StructContainingEnds(ctx_ _bindings.Context, in ProtocolEnds) (ProtocolEnds, error) {
	req_ := &WithProtocolEndsStructContainingEndsRequest{In: in}
	resp_ := &WithProtocolEndsStructContainingEndsResponse{}
	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 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_ := &WithProtocolEndsClientEndsRequest{}
		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_ := &WithProtocolEndsClientEndsResponse{Out: out}
		return out_, true, err_
	case WithProtocolEndsServerEndsOrdinal:
		in_ := &WithProtocolEndsServerEndsRequest{}
		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_ := &WithProtocolEndsServerEndsResponse{Out: out}
		return out_, true, err_
	case WithProtocolEndsStructContainingEndsOrdinal:
		in_ := &WithProtocolEndsStructContainingEndsRequest{}
		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_ := &WithProtocolEndsStructContainingEndsResponse{Out: out}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type WithProtocolEndsEventProxy _bindings.ChannelProxy