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

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

// fidl_experiment = output_index_json

package protocollayoutssamelibrary

import (
	_bindings "syscall/zx/fidl"
)

type I_composedProtocolOnAnonComposedRequestTag uint64

const (
	ComposedProtocolOnAnonComposedRequestB = 1 // 0x00000001
)

type ComposedProtocolOnAnonComposedRequest struct {
	I_composedProtocolOnAnonComposedRequestTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	B                                          bool `fidl_ordinal:"1"`
}

var _mComposedProtocolOnAnonComposedRequest = _bindings.CreateLazyMarshaler(ComposedProtocolOnAnonComposedRequest{})

func (msg *ComposedProtocolOnAnonComposedRequest) Marshaler() _bindings.Marshaler {
	return _mComposedProtocolOnAnonComposedRequest
}

func (_m *ComposedProtocolOnAnonComposedRequest) reset() {
	switch _m.I_composedProtocolOnAnonComposedRequestTag {
	case 1:
		var _zeroed bool
		_m.B = _zeroed
	}
}

func (_m *ComposedProtocolOnAnonComposedRequest) Which() I_composedProtocolOnAnonComposedRequestTag {
	return _m.I_composedProtocolOnAnonComposedRequestTag
}

func (_m *ComposedProtocolOnAnonComposedRequest) Ordinal() uint64 {
	return uint64(_m.I_composedProtocolOnAnonComposedRequestTag)
}

func (_m *ComposedProtocolOnAnonComposedRequest) SetB(b bool) {
	_m.reset()
	_m.I_composedProtocolOnAnonComposedRequestTag = ComposedProtocolOnAnonComposedRequestB
	_m.B = b
}

func ComposedProtocolOnAnonComposedRequestWithB(b bool) ComposedProtocolOnAnonComposedRequest {
	var _u ComposedProtocolOnAnonComposedRequest
	_u.SetB(b)
	return _u
}

type I_composedProtocolTwoWayAnonComposedRequestTag uint64

const (
	ComposedProtocolTwoWayAnonComposedRequestB = 1 // 0x00000001
)

type ComposedProtocolTwoWayAnonComposedRequest struct {
	I_composedProtocolTwoWayAnonComposedRequestTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	B                                              bool `fidl_ordinal:"1"`
}

var _mComposedProtocolTwoWayAnonComposedRequest = _bindings.CreateLazyMarshaler(ComposedProtocolTwoWayAnonComposedRequest{})

func (msg *ComposedProtocolTwoWayAnonComposedRequest) Marshaler() _bindings.Marshaler {
	return _mComposedProtocolTwoWayAnonComposedRequest
}

func (_m *ComposedProtocolTwoWayAnonComposedRequest) reset() {
	switch _m.I_composedProtocolTwoWayAnonComposedRequestTag {
	case 1:
		var _zeroed bool
		_m.B = _zeroed
	}
}

func (_m *ComposedProtocolTwoWayAnonComposedRequest) Which() I_composedProtocolTwoWayAnonComposedRequestTag {
	return _m.I_composedProtocolTwoWayAnonComposedRequestTag
}

func (_m *ComposedProtocolTwoWayAnonComposedRequest) Ordinal() uint64 {
	return uint64(_m.I_composedProtocolTwoWayAnonComposedRequestTag)
}

func (_m *ComposedProtocolTwoWayAnonComposedRequest) SetB(b bool) {
	_m.reset()
	_m.I_composedProtocolTwoWayAnonComposedRequestTag = ComposedProtocolTwoWayAnonComposedRequestB
	_m.B = b
}

func ComposedProtocolTwoWayAnonComposedRequestWithB(b bool) ComposedProtocolTwoWayAnonComposedRequest {
	var _u ComposedProtocolTwoWayAnonComposedRequest
	_u.SetB(b)
	return _u
}

type I_composedProtocolTwoWayAnonComposedWithErrorResponseTag uint64

const (
	ComposedProtocolTwoWayAnonComposedWithErrorResponseB = 1 // 0x00000001
)

type ComposedProtocolTwoWayAnonComposedWithErrorResponse struct {
	I_composedProtocolTwoWayAnonComposedWithErrorResponseTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	B                                                        bool `fidl_ordinal:"1"`
}

var _mComposedProtocolTwoWayAnonComposedWithErrorResponse = _bindings.CreateLazyMarshaler(ComposedProtocolTwoWayAnonComposedWithErrorResponse{})

func (msg *ComposedProtocolTwoWayAnonComposedWithErrorResponse) Marshaler() _bindings.Marshaler {
	return _mComposedProtocolTwoWayAnonComposedWithErrorResponse
}

func (_m *ComposedProtocolTwoWayAnonComposedWithErrorResponse) reset() {
	switch _m.I_composedProtocolTwoWayAnonComposedWithErrorResponseTag {
	case 1:
		var _zeroed bool
		_m.B = _zeroed
	}
}

func (_m *ComposedProtocolTwoWayAnonComposedWithErrorResponse) Which() I_composedProtocolTwoWayAnonComposedWithErrorResponseTag {
	return _m.I_composedProtocolTwoWayAnonComposedWithErrorResponseTag
}

func (_m *ComposedProtocolTwoWayAnonComposedWithErrorResponse) Ordinal() uint64 {
	return uint64(_m.I_composedProtocolTwoWayAnonComposedWithErrorResponseTag)
}

func (_m *ComposedProtocolTwoWayAnonComposedWithErrorResponse) SetB(b bool) {
	_m.reset()
	_m.I_composedProtocolTwoWayAnonComposedWithErrorResponseTag = ComposedProtocolTwoWayAnonComposedWithErrorResponseB
	_m.B = b
}

func ComposedProtocolTwoWayAnonComposedWithErrorResponseWithB(b bool) ComposedProtocolTwoWayAnonComposedWithErrorResponse {
	var _u ComposedProtocolTwoWayAnonComposedWithErrorResponse
	_u.SetB(b)
	return _u
}

type I_composedProtocolTwoWayAnonComposedWithErrorResultTag uint64

const (
	ComposedProtocolTwoWayAnonComposedWithErrorResultResponse = 1 // 0x00000001
	ComposedProtocolTwoWayAnonComposedWithErrorResultErr      = 2 // 0x00000002
)

type ComposedProtocolTwoWayAnonComposedWithErrorResult struct {
	I_composedProtocolTwoWayAnonComposedWithErrorResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                               ComposedProtocolTwoWayAnonComposedWithErrorResponse `fidl_ordinal:"1"`
	Err                                                    uint32                                              `fidl_ordinal:"2"`
}

var _mComposedProtocolTwoWayAnonComposedWithErrorResult = _bindings.CreateLazyMarshaler(ComposedProtocolTwoWayAnonComposedWithErrorResult{})

func (msg *ComposedProtocolTwoWayAnonComposedWithErrorResult) Marshaler() _bindings.Marshaler {
	return _mComposedProtocolTwoWayAnonComposedWithErrorResult
}

func (_m *ComposedProtocolTwoWayAnonComposedWithErrorResult) reset() {
	switch _m.I_composedProtocolTwoWayAnonComposedWithErrorResultTag {
	case 1:
		var _zeroed ComposedProtocolTwoWayAnonComposedWithErrorResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed uint32
		_m.Err = _zeroed
	}
}

func (_m *ComposedProtocolTwoWayAnonComposedWithErrorResult) Which() I_composedProtocolTwoWayAnonComposedWithErrorResultTag {
	return _m.I_composedProtocolTwoWayAnonComposedWithErrorResultTag
}

func (_m *ComposedProtocolTwoWayAnonComposedWithErrorResult) Ordinal() uint64 {
	return uint64(_m.I_composedProtocolTwoWayAnonComposedWithErrorResultTag)
}

func (_m *ComposedProtocolTwoWayAnonComposedWithErrorResult) SetResponse(response ComposedProtocolTwoWayAnonComposedWithErrorResponse) {
	_m.reset()
	_m.I_composedProtocolTwoWayAnonComposedWithErrorResultTag = ComposedProtocolTwoWayAnonComposedWithErrorResultResponse
	_m.Response = response
}

func ComposedProtocolTwoWayAnonComposedWithErrorResultWithResponse(response ComposedProtocolTwoWayAnonComposedWithErrorResponse) ComposedProtocolTwoWayAnonComposedWithErrorResult {
	var _u ComposedProtocolTwoWayAnonComposedWithErrorResult
	_u.SetResponse(response)
	return _u
}

func (_m *ComposedProtocolTwoWayAnonComposedWithErrorResult) SetErr(err uint32) {
	_m.reset()
	_m.I_composedProtocolTwoWayAnonComposedWithErrorResultTag = ComposedProtocolTwoWayAnonComposedWithErrorResultErr
	_m.Err = err
}

func ComposedProtocolTwoWayAnonComposedWithErrorResultWithErr(err uint32) ComposedProtocolTwoWayAnonComposedWithErrorResult {
	var _u ComposedProtocolTwoWayAnonComposedWithErrorResult
	_u.SetErr(err)
	return _u
}

type I_composedProtocolTwoWayNamedComposedWithErrorResultTag uint64

const (
	ComposedProtocolTwoWayNamedComposedWithErrorResultResponse = 1 // 0x00000001
	ComposedProtocolTwoWayNamedComposedWithErrorResultErr      = 2 // 0x00000002
)

type ComposedProtocolTwoWayNamedComposedWithErrorResult struct {
	I_composedProtocolTwoWayNamedComposedWithErrorResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                                UnionPayload `fidl_ordinal:"1"`
	Err                                                     uint32       `fidl_ordinal:"2"`
}

var _mComposedProtocolTwoWayNamedComposedWithErrorResult = _bindings.CreateLazyMarshaler(ComposedProtocolTwoWayNamedComposedWithErrorResult{})

func (msg *ComposedProtocolTwoWayNamedComposedWithErrorResult) Marshaler() _bindings.Marshaler {
	return _mComposedProtocolTwoWayNamedComposedWithErrorResult
}

func (_m *ComposedProtocolTwoWayNamedComposedWithErrorResult) reset() {
	switch _m.I_composedProtocolTwoWayNamedComposedWithErrorResultTag {
	case 1:
		var _zeroed UnionPayload
		_m.Response = _zeroed
	case 2:
		var _zeroed uint32
		_m.Err = _zeroed
	}
}

func (_m *ComposedProtocolTwoWayNamedComposedWithErrorResult) Which() I_composedProtocolTwoWayNamedComposedWithErrorResultTag {
	return _m.I_composedProtocolTwoWayNamedComposedWithErrorResultTag
}

func (_m *ComposedProtocolTwoWayNamedComposedWithErrorResult) Ordinal() uint64 {
	return uint64(_m.I_composedProtocolTwoWayNamedComposedWithErrorResultTag)
}

func (_m *ComposedProtocolTwoWayNamedComposedWithErrorResult) SetResponse(response UnionPayload) {
	_m.reset()
	_m.I_composedProtocolTwoWayNamedComposedWithErrorResultTag = ComposedProtocolTwoWayNamedComposedWithErrorResultResponse
	_m.Response = response
}

func ComposedProtocolTwoWayNamedComposedWithErrorResultWithResponse(response UnionPayload) ComposedProtocolTwoWayNamedComposedWithErrorResult {
	var _u ComposedProtocolTwoWayNamedComposedWithErrorResult
	_u.SetResponse(response)
	return _u
}

func (_m *ComposedProtocolTwoWayNamedComposedWithErrorResult) SetErr(err uint32) {
	_m.reset()
	_m.I_composedProtocolTwoWayNamedComposedWithErrorResultTag = ComposedProtocolTwoWayNamedComposedWithErrorResultErr
	_m.Err = err
}

func ComposedProtocolTwoWayNamedComposedWithErrorResultWithErr(err uint32) ComposedProtocolTwoWayNamedComposedWithErrorResult {
	var _u ComposedProtocolTwoWayNamedComposedWithErrorResult
	_u.SetErr(err)
	return _u
}

type I_mainProtocolOnAnonRequestTag uint64

const (
	MainProtocolOnAnonRequest_unknownData = 0 // 0x00000000
	MainProtocolOnAnonRequestB            = 1 // 0x00000001
)

type MainProtocolOnAnonRequest struct {
	I_mainProtocolOnAnonRequestTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData                  interface{}
	B                              bool `fidl_ordinal:"1"`
}

var _mMainProtocolOnAnonRequest = _bindings.CreateLazyMarshaler(MainProtocolOnAnonRequest{})

func (msg *MainProtocolOnAnonRequest) Marshaler() _bindings.Marshaler {
	return _mMainProtocolOnAnonRequest
}

func (_m *MainProtocolOnAnonRequest) reset() {
	switch _m.I_mainProtocolOnAnonRequestTag {
	case 1:
		var _zeroed bool
		_m.B = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *MainProtocolOnAnonRequest) Which() I_mainProtocolOnAnonRequestTag {
	switch _m.I_mainProtocolOnAnonRequestTag {
	case 1:
		return MainProtocolOnAnonRequestB
	default:
		return MainProtocolOnAnonRequest_unknownData
	}
}

func (_m *MainProtocolOnAnonRequest) Ordinal() uint64 {
	return uint64(_m.I_mainProtocolOnAnonRequestTag)
}

func (_m *MainProtocolOnAnonRequest) SetB(b bool) {
	_m.reset()
	_m.I_mainProtocolOnAnonRequestTag = MainProtocolOnAnonRequestB
	_m.B = b
}

func MainProtocolOnAnonRequestWithB(b bool) MainProtocolOnAnonRequest {
	var _u MainProtocolOnAnonRequest
	_u.SetB(b)
	return _u
}
func (_m *MainProtocolOnAnonRequest) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_mainProtocolTwoWayAnonRequestTag uint64

const (
	MainProtocolTwoWayAnonRequest_unknownData = 0 // 0x00000000
	MainProtocolTwoWayAnonRequestB            = 1 // 0x00000001
)

type MainProtocolTwoWayAnonRequest struct {
	I_mainProtocolTwoWayAnonRequestTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData                      interface{}
	B                                  bool `fidl_ordinal:"1"`
}

var _mMainProtocolTwoWayAnonRequest = _bindings.CreateLazyMarshaler(MainProtocolTwoWayAnonRequest{})

func (msg *MainProtocolTwoWayAnonRequest) Marshaler() _bindings.Marshaler {
	return _mMainProtocolTwoWayAnonRequest
}

func (_m *MainProtocolTwoWayAnonRequest) reset() {
	switch _m.I_mainProtocolTwoWayAnonRequestTag {
	case 1:
		var _zeroed bool
		_m.B = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *MainProtocolTwoWayAnonRequest) Which() I_mainProtocolTwoWayAnonRequestTag {
	switch _m.I_mainProtocolTwoWayAnonRequestTag {
	case 1:
		return MainProtocolTwoWayAnonRequestB
	default:
		return MainProtocolTwoWayAnonRequest_unknownData
	}
}

func (_m *MainProtocolTwoWayAnonRequest) Ordinal() uint64 {
	return uint64(_m.I_mainProtocolTwoWayAnonRequestTag)
}

func (_m *MainProtocolTwoWayAnonRequest) SetB(b bool) {
	_m.reset()
	_m.I_mainProtocolTwoWayAnonRequestTag = MainProtocolTwoWayAnonRequestB
	_m.B = b
}

func MainProtocolTwoWayAnonRequestWithB(b bool) MainProtocolTwoWayAnonRequest {
	var _u MainProtocolTwoWayAnonRequest
	_u.SetB(b)
	return _u
}
func (_m *MainProtocolTwoWayAnonRequest) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_mainProtocolTwoWayAnonWithErrorResponseTag uint64

const (
	MainProtocolTwoWayAnonWithErrorResponse_unknownData = 0 // 0x00000000
	MainProtocolTwoWayAnonWithErrorResponseB            = 1 // 0x00000001
)

type MainProtocolTwoWayAnonWithErrorResponse struct {
	I_mainProtocolTwoWayAnonWithErrorResponseTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData                                interface{}
	B                                            bool `fidl_ordinal:"1"`
}

var _mMainProtocolTwoWayAnonWithErrorResponse = _bindings.CreateLazyMarshaler(MainProtocolTwoWayAnonWithErrorResponse{})

func (msg *MainProtocolTwoWayAnonWithErrorResponse) Marshaler() _bindings.Marshaler {
	return _mMainProtocolTwoWayAnonWithErrorResponse
}

func (_m *MainProtocolTwoWayAnonWithErrorResponse) reset() {
	switch _m.I_mainProtocolTwoWayAnonWithErrorResponseTag {
	case 1:
		var _zeroed bool
		_m.B = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *MainProtocolTwoWayAnonWithErrorResponse) Which() I_mainProtocolTwoWayAnonWithErrorResponseTag {
	switch _m.I_mainProtocolTwoWayAnonWithErrorResponseTag {
	case 1:
		return MainProtocolTwoWayAnonWithErrorResponseB
	default:
		return MainProtocolTwoWayAnonWithErrorResponse_unknownData
	}
}

func (_m *MainProtocolTwoWayAnonWithErrorResponse) Ordinal() uint64 {
	return uint64(_m.I_mainProtocolTwoWayAnonWithErrorResponseTag)
}

func (_m *MainProtocolTwoWayAnonWithErrorResponse) SetB(b bool) {
	_m.reset()
	_m.I_mainProtocolTwoWayAnonWithErrorResponseTag = MainProtocolTwoWayAnonWithErrorResponseB
	_m.B = b
}

func MainProtocolTwoWayAnonWithErrorResponseWithB(b bool) MainProtocolTwoWayAnonWithErrorResponse {
	var _u MainProtocolTwoWayAnonWithErrorResponse
	_u.SetB(b)
	return _u
}
func (_m *MainProtocolTwoWayAnonWithErrorResponse) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_mainProtocolTwoWayAnonWithErrorResultTag uint64

const (
	MainProtocolTwoWayAnonWithErrorResultResponse = 1 // 0x00000001
	MainProtocolTwoWayAnonWithErrorResultErr      = 2 // 0x00000002
)

type MainProtocolTwoWayAnonWithErrorResult struct {
	I_mainProtocolTwoWayAnonWithErrorResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                   MainProtocolTwoWayAnonWithErrorResponse `fidl_ordinal:"1"`
	Err                                        uint32                                  `fidl_ordinal:"2"`
}

var _mMainProtocolTwoWayAnonWithErrorResult = _bindings.CreateLazyMarshaler(MainProtocolTwoWayAnonWithErrorResult{})

func (msg *MainProtocolTwoWayAnonWithErrorResult) Marshaler() _bindings.Marshaler {
	return _mMainProtocolTwoWayAnonWithErrorResult
}

func (_m *MainProtocolTwoWayAnonWithErrorResult) reset() {
	switch _m.I_mainProtocolTwoWayAnonWithErrorResultTag {
	case 1:
		var _zeroed MainProtocolTwoWayAnonWithErrorResponse
		_m.Response = _zeroed
	case 2:
		var _zeroed uint32
		_m.Err = _zeroed
	}
}

func (_m *MainProtocolTwoWayAnonWithErrorResult) Which() I_mainProtocolTwoWayAnonWithErrorResultTag {
	return _m.I_mainProtocolTwoWayAnonWithErrorResultTag
}

func (_m *MainProtocolTwoWayAnonWithErrorResult) Ordinal() uint64 {
	return uint64(_m.I_mainProtocolTwoWayAnonWithErrorResultTag)
}

func (_m *MainProtocolTwoWayAnonWithErrorResult) SetResponse(response MainProtocolTwoWayAnonWithErrorResponse) {
	_m.reset()
	_m.I_mainProtocolTwoWayAnonWithErrorResultTag = MainProtocolTwoWayAnonWithErrorResultResponse
	_m.Response = response
}

func MainProtocolTwoWayAnonWithErrorResultWithResponse(response MainProtocolTwoWayAnonWithErrorResponse) MainProtocolTwoWayAnonWithErrorResult {
	var _u MainProtocolTwoWayAnonWithErrorResult
	_u.SetResponse(response)
	return _u
}

func (_m *MainProtocolTwoWayAnonWithErrorResult) SetErr(err uint32) {
	_m.reset()
	_m.I_mainProtocolTwoWayAnonWithErrorResultTag = MainProtocolTwoWayAnonWithErrorResultErr
	_m.Err = err
}

func MainProtocolTwoWayAnonWithErrorResultWithErr(err uint32) MainProtocolTwoWayAnonWithErrorResult {
	var _u MainProtocolTwoWayAnonWithErrorResult
	_u.SetErr(err)
	return _u
}

type I_mainProtocolTwoWayLocalWithErrorResultTag uint64

const (
	MainProtocolTwoWayLocalWithErrorResultResponse = 1 // 0x00000001
	MainProtocolTwoWayLocalWithErrorResultErr      = 2 // 0x00000002
)

type MainProtocolTwoWayLocalWithErrorResult struct {
	I_mainProtocolTwoWayLocalWithErrorResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Response                                    UnionPayload `fidl_ordinal:"1"`
	Err                                         uint32       `fidl_ordinal:"2"`
}

var _mMainProtocolTwoWayLocalWithErrorResult = _bindings.CreateLazyMarshaler(MainProtocolTwoWayLocalWithErrorResult{})

func (msg *MainProtocolTwoWayLocalWithErrorResult) Marshaler() _bindings.Marshaler {
	return _mMainProtocolTwoWayLocalWithErrorResult
}

func (_m *MainProtocolTwoWayLocalWithErrorResult) reset() {
	switch _m.I_mainProtocolTwoWayLocalWithErrorResultTag {
	case 1:
		var _zeroed UnionPayload
		_m.Response = _zeroed
	case 2:
		var _zeroed uint32
		_m.Err = _zeroed
	}
}

func (_m *MainProtocolTwoWayLocalWithErrorResult) Which() I_mainProtocolTwoWayLocalWithErrorResultTag {
	return _m.I_mainProtocolTwoWayLocalWithErrorResultTag
}

func (_m *MainProtocolTwoWayLocalWithErrorResult) Ordinal() uint64 {
	return uint64(_m.I_mainProtocolTwoWayLocalWithErrorResultTag)
}

func (_m *MainProtocolTwoWayLocalWithErrorResult) SetResponse(response UnionPayload) {
	_m.reset()
	_m.I_mainProtocolTwoWayLocalWithErrorResultTag = MainProtocolTwoWayLocalWithErrorResultResponse
	_m.Response = response
}

func MainProtocolTwoWayLocalWithErrorResultWithResponse(response UnionPayload) MainProtocolTwoWayLocalWithErrorResult {
	var _u MainProtocolTwoWayLocalWithErrorResult
	_u.SetResponse(response)
	return _u
}

func (_m *MainProtocolTwoWayLocalWithErrorResult) SetErr(err uint32) {
	_m.reset()
	_m.I_mainProtocolTwoWayLocalWithErrorResultTag = MainProtocolTwoWayLocalWithErrorResultErr
	_m.Err = err
}

func MainProtocolTwoWayLocalWithErrorResultWithErr(err uint32) MainProtocolTwoWayLocalWithErrorResult {
	var _u MainProtocolTwoWayLocalWithErrorResult
	_u.SetErr(err)
	return _u
}

type I_unionPayloadTag uint64

const (
	UnionPayloadB = 1 // 0x00000001
)

type UnionPayload struct {
	I_unionPayloadTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	B                 bool `fidl_ordinal:"1"`
}

var _mUnionPayload = _bindings.CreateLazyMarshaler(UnionPayload{})

func (msg *UnionPayload) Marshaler() _bindings.Marshaler {
	return _mUnionPayload
}

func (_m *UnionPayload) reset() {
	switch _m.I_unionPayloadTag {
	case 1:
		var _zeroed bool
		_m.B = _zeroed
	}
}

func (_m *UnionPayload) Which() I_unionPayloadTag {
	return _m.I_unionPayloadTag
}

func (_m *UnionPayload) Ordinal() uint64 {
	return uint64(_m.I_unionPayloadTag)
}

func (_m *UnionPayload) SetB(b bool) {
	_m.reset()
	_m.I_unionPayloadTag = UnionPayloadB
	_m.B = b
}

func UnionPayloadWithB(b bool) UnionPayload {
	var _u UnionPayload
	_u.SetB(b)
	return _u
}

type ComposedProtocolOneWayAnonComposedRequest struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	A             uint16 `fidl_ordinal:"1"`
	APresent      bool
}

var _mComposedProtocolOneWayAnonComposedRequest = _bindings.CreateLazyMarshaler(ComposedProtocolOneWayAnonComposedRequest{})

func (msg *ComposedProtocolOneWayAnonComposedRequest) Marshaler() _bindings.Marshaler {
	return _mComposedProtocolOneWayAnonComposedRequest
}

func (u *ComposedProtocolOneWayAnonComposedRequest) SetA(a uint16) {
	u.A = a
	u.APresent = true
}

func (u *ComposedProtocolOneWayAnonComposedRequest) GetA() uint16 {
	return u.A
}

func (u *ComposedProtocolOneWayAnonComposedRequest) GetAWithDefault(_default uint16) uint16 {
	if !u.HasA() {
		return _default
	}
	return u.A
}

func (u *ComposedProtocolOneWayAnonComposedRequest) HasA() bool {
	return u.APresent
}

func (u *ComposedProtocolOneWayAnonComposedRequest) ClearA() {
	u.APresent = false
}

func (u *ComposedProtocolOneWayAnonComposedRequest) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *ComposedProtocolOneWayAnonComposedRequest) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type ComposedProtocolTwoWayAnonComposedResponse struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	A             uint16 `fidl_ordinal:"1"`
	APresent      bool
}

var _mComposedProtocolTwoWayAnonComposedResponse = _bindings.CreateLazyMarshaler(ComposedProtocolTwoWayAnonComposedResponse{})

func (msg *ComposedProtocolTwoWayAnonComposedResponse) Marshaler() _bindings.Marshaler {
	return _mComposedProtocolTwoWayAnonComposedResponse
}

func (u *ComposedProtocolTwoWayAnonComposedResponse) SetA(a uint16) {
	u.A = a
	u.APresent = true
}

func (u *ComposedProtocolTwoWayAnonComposedResponse) GetA() uint16 {
	return u.A
}

func (u *ComposedProtocolTwoWayAnonComposedResponse) GetAWithDefault(_default uint16) uint16 {
	if !u.HasA() {
		return _default
	}
	return u.A
}

func (u *ComposedProtocolTwoWayAnonComposedResponse) HasA() bool {
	return u.APresent
}

func (u *ComposedProtocolTwoWayAnonComposedResponse) ClearA() {
	u.APresent = false
}

func (u *ComposedProtocolTwoWayAnonComposedResponse) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *ComposedProtocolTwoWayAnonComposedResponse) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type ComposedProtocolTwoWayAnonComposedWithErrorRequest struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	A             uint16 `fidl_ordinal:"1"`
	APresent      bool
}

var _mComposedProtocolTwoWayAnonComposedWithErrorRequest = _bindings.CreateLazyMarshaler(ComposedProtocolTwoWayAnonComposedWithErrorRequest{})

func (msg *ComposedProtocolTwoWayAnonComposedWithErrorRequest) Marshaler() _bindings.Marshaler {
	return _mComposedProtocolTwoWayAnonComposedWithErrorRequest
}

func (u *ComposedProtocolTwoWayAnonComposedWithErrorRequest) SetA(a uint16) {
	u.A = a
	u.APresent = true
}

func (u *ComposedProtocolTwoWayAnonComposedWithErrorRequest) GetA() uint16 {
	return u.A
}

func (u *ComposedProtocolTwoWayAnonComposedWithErrorRequest) GetAWithDefault(_default uint16) uint16 {
	if !u.HasA() {
		return _default
	}
	return u.A
}

func (u *ComposedProtocolTwoWayAnonComposedWithErrorRequest) HasA() bool {
	return u.APresent
}

func (u *ComposedProtocolTwoWayAnonComposedWithErrorRequest) ClearA() {
	u.APresent = false
}

func (u *ComposedProtocolTwoWayAnonComposedWithErrorRequest) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *ComposedProtocolTwoWayAnonComposedWithErrorRequest) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type MainProtocolOneWayAnonRequest struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	A             uint16 `fidl_ordinal:"1"`
	APresent      bool
}

var _mMainProtocolOneWayAnonRequest = _bindings.CreateLazyMarshaler(MainProtocolOneWayAnonRequest{})

func (msg *MainProtocolOneWayAnonRequest) Marshaler() _bindings.Marshaler {
	return _mMainProtocolOneWayAnonRequest
}

func (u *MainProtocolOneWayAnonRequest) SetA(a uint16) {
	u.A = a
	u.APresent = true
}

func (u *MainProtocolOneWayAnonRequest) GetA() uint16 {
	return u.A
}

func (u *MainProtocolOneWayAnonRequest) GetAWithDefault(_default uint16) uint16 {
	if !u.HasA() {
		return _default
	}
	return u.A
}

func (u *MainProtocolOneWayAnonRequest) HasA() bool {
	return u.APresent
}

func (u *MainProtocolOneWayAnonRequest) ClearA() {
	u.APresent = false
}

func (u *MainProtocolOneWayAnonRequest) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *MainProtocolOneWayAnonRequest) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type MainProtocolTwoWayAnonResponse struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	A             uint16 `fidl_ordinal:"1"`
	APresent      bool
}

var _mMainProtocolTwoWayAnonResponse = _bindings.CreateLazyMarshaler(MainProtocolTwoWayAnonResponse{})

func (msg *MainProtocolTwoWayAnonResponse) Marshaler() _bindings.Marshaler {
	return _mMainProtocolTwoWayAnonResponse
}

func (u *MainProtocolTwoWayAnonResponse) SetA(a uint16) {
	u.A = a
	u.APresent = true
}

func (u *MainProtocolTwoWayAnonResponse) GetA() uint16 {
	return u.A
}

func (u *MainProtocolTwoWayAnonResponse) GetAWithDefault(_default uint16) uint16 {
	if !u.HasA() {
		return _default
	}
	return u.A
}

func (u *MainProtocolTwoWayAnonResponse) HasA() bool {
	return u.APresent
}

func (u *MainProtocolTwoWayAnonResponse) ClearA() {
	u.APresent = false
}

func (u *MainProtocolTwoWayAnonResponse) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *MainProtocolTwoWayAnonResponse) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type MainProtocolTwoWayAnonWithErrorRequest struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	A             uint16 `fidl_ordinal:"1"`
	APresent      bool
}

var _mMainProtocolTwoWayAnonWithErrorRequest = _bindings.CreateLazyMarshaler(MainProtocolTwoWayAnonWithErrorRequest{})

func (msg *MainProtocolTwoWayAnonWithErrorRequest) Marshaler() _bindings.Marshaler {
	return _mMainProtocolTwoWayAnonWithErrorRequest
}

func (u *MainProtocolTwoWayAnonWithErrorRequest) SetA(a uint16) {
	u.A = a
	u.APresent = true
}

func (u *MainProtocolTwoWayAnonWithErrorRequest) GetA() uint16 {
	return u.A
}

func (u *MainProtocolTwoWayAnonWithErrorRequest) GetAWithDefault(_default uint16) uint16 {
	if !u.HasA() {
		return _default
	}
	return u.A
}

func (u *MainProtocolTwoWayAnonWithErrorRequest) HasA() bool {
	return u.APresent
}

func (u *MainProtocolTwoWayAnonWithErrorRequest) ClearA() {
	u.APresent = false
}

func (u *MainProtocolTwoWayAnonWithErrorRequest) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *MainProtocolTwoWayAnonWithErrorRequest) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

type TablePayload struct {
	_             struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData interface{}
	A             uint16 `fidl_ordinal:"1"`
	APresent      bool
}

var _mTablePayload = _bindings.CreateLazyMarshaler(TablePayload{})

func (msg *TablePayload) Marshaler() _bindings.Marshaler {
	return _mTablePayload
}

func (u *TablePayload) SetA(a uint16) {
	u.A = a
	u.APresent = true
}

func (u *TablePayload) GetA() uint16 {
	return u.A
}

func (u *TablePayload) GetAWithDefault(_default uint16) uint16 {
	if !u.HasA() {
		return _default
	}
	return u.A
}

func (u *TablePayload) HasA() bool {
	return u.APresent
}

func (u *TablePayload) ClearA() {
	u.APresent = false
}

func (u *TablePayload) HasUnknownData() bool {
	return u.I_unknownData != nil
}

func (u *TablePayload) GetUnknownData() map[uint64]_bindings.UnknownData {
	return u.I_unknownData.(map[uint64]_bindings.UnknownData)
}

const (
	ComposedProtocolOneWayAnonComposedOrdinal           uint64 = 0x6e7a205bdad7941f
	ComposedProtocolTwoWayAnonComposedOrdinal           uint64 = 0x7083713dee9435f4
	ComposedProtocolTwoWayAnonComposedWithErrorOrdinal  uint64 = 0x4fd32c5e2ffa6828
	ComposedProtocolOnAnonComposedOrdinal               uint64 = 0x49a6eee3a0300e28
	ComposedProtocolOneWayNamedComposedOrdinal          uint64 = 0x101636a8fa3e69b8
	ComposedProtocolTwoWayNamedComposedOrdinal          uint64 = 0x45b4d3d31b374054
	ComposedProtocolTwoWayNamedComposedWithErrorOrdinal uint64 = 0x450531e2d20c52ef
	ComposedProtocolOnNamedComposedOrdinal              uint64 = 0x17c4edb4a4a36d7b
)

type ComposedProtocolWithCtxInterface _bindings.ChannelProxy

func (p *ComposedProtocolWithCtxInterface) OneWayAnonComposed(ctx_ _bindings.Context, payload ComposedProtocolOneWayAnonComposedRequest) error {
	req_ := &payload
	err_ := ((*_bindings.ChannelProxy)(p)).Send(ComposedProtocolOneWayAnonComposedOrdinal, req_)
	return err_
}

func (p *ComposedProtocolWithCtxInterface) TwoWayAnonComposed(ctx_ _bindings.Context, payload ComposedProtocolTwoWayAnonComposedRequest) (ComposedProtocolTwoWayAnonComposedResponse, error) {
	req_ := &payload
	resp_ := &ComposedProtocolTwoWayAnonComposedResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ComposedProtocolTwoWayAnonComposedOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *ComposedProtocolWithCtxInterface) TwoWayAnonComposedWithError(ctx_ _bindings.Context, payload ComposedProtocolTwoWayAnonComposedWithErrorRequest) (ComposedProtocolTwoWayAnonComposedWithErrorResult, error) {
	req_ := &payload
	resp_ := &ComposedProtocolTwoWayAnonComposedWithErrorResult{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ComposedProtocolTwoWayAnonComposedWithErrorOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *ComposedProtocolWithCtxInterface) ExpectOnAnonComposed(ctx_ _bindings.Context) (ComposedProtocolOnAnonComposedRequest, error) {
	resp_ := &ComposedProtocolOnAnonComposedRequest{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(ComposedProtocolOnAnonComposedOrdinal, resp_)
	return (*resp_), err_
}

func (p *ComposedProtocolWithCtxInterface) OneWayNamedComposed(ctx_ _bindings.Context, payload TablePayload) error {
	req_ := &payload
	err_ := ((*_bindings.ChannelProxy)(p)).Send(ComposedProtocolOneWayNamedComposedOrdinal, req_)
	return err_
}

func (p *ComposedProtocolWithCtxInterface) TwoWayNamedComposed(ctx_ _bindings.Context, payload UnionPayload) (TablePayload, error) {
	req_ := &payload
	resp_ := &TablePayload{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ComposedProtocolTwoWayNamedComposedOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *ComposedProtocolWithCtxInterface) TwoWayNamedComposedWithError(ctx_ _bindings.Context, payload TablePayload) (ComposedProtocolTwoWayNamedComposedWithErrorResult, error) {
	req_ := &payload
	resp_ := &ComposedProtocolTwoWayNamedComposedWithErrorResult{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(ComposedProtocolTwoWayNamedComposedWithErrorOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *ComposedProtocolWithCtxInterface) ExpectOnNamedComposed(ctx_ _bindings.Context) (UnionPayload, error) {
	resp_ := &UnionPayload{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(ComposedProtocolOnNamedComposedOrdinal, resp_)
	return (*resp_), err_
}

type ComposedProtocolWithCtx interface {
	OneWayAnonComposed(ctx_ _bindings.Context, payload ComposedProtocolOneWayAnonComposedRequest) error
	TwoWayAnonComposed(ctx_ _bindings.Context, payload ComposedProtocolTwoWayAnonComposedRequest) (ComposedProtocolTwoWayAnonComposedResponse, error)
	TwoWayAnonComposedWithError(ctx_ _bindings.Context, payload ComposedProtocolTwoWayAnonComposedWithErrorRequest) (ComposedProtocolTwoWayAnonComposedWithErrorResult, error)
	OneWayNamedComposed(ctx_ _bindings.Context, payload TablePayload) error
	TwoWayNamedComposed(ctx_ _bindings.Context, payload UnionPayload) (TablePayload, error)
	TwoWayNamedComposedWithError(ctx_ _bindings.Context, payload TablePayload) (ComposedProtocolTwoWayNamedComposedWithErrorResult, error)
}
type ComposedProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewComposedProtocolWithCtxInterfaceRequest() (ComposedProtocolWithCtxInterfaceRequest, *ComposedProtocolWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return ComposedProtocolWithCtxInterfaceRequest(req), (*ComposedProtocolWithCtxInterface)(cli), err
}

type ComposedProtocolWithCtxStub struct {
	Impl ComposedProtocolWithCtx
}

func (s_ *ComposedProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case ComposedProtocolOneWayAnonComposedOrdinal:
		in_ := &ComposedProtocolOneWayAnonComposedRequest{}
		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.OneWayAnonComposed(args_.Ctx, (*in_))
		return nil, false, err_
	case ComposedProtocolTwoWayAnonComposedOrdinal:
		in_ := &ComposedProtocolTwoWayAnonComposedRequest{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayAnonComposed(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	case ComposedProtocolTwoWayAnonComposedWithErrorOrdinal:
		in_ := &ComposedProtocolTwoWayAnonComposedWithErrorRequest{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayAnonComposedWithError(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	case ComposedProtocolOneWayNamedComposedOrdinal:
		in_ := &TablePayload{}
		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.OneWayNamedComposed(args_.Ctx, (*in_))
		return nil, false, err_
	case ComposedProtocolTwoWayNamedComposedOrdinal:
		in_ := &UnionPayload{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayNamedComposed(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	case ComposedProtocolTwoWayNamedComposedWithErrorOrdinal:
		in_ := &TablePayload{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayNamedComposedWithError(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type ComposedProtocolEventProxy _bindings.ChannelProxy

func (p *ComposedProtocolEventProxy) OnAnonComposed(payload ComposedProtocolOnAnonComposedRequest) error {
	event_ := &payload
	return ((*_bindings.ChannelProxy)(p)).Send(ComposedProtocolOnAnonComposedOrdinal, event_)
}
func (p *ComposedProtocolEventProxy) OnNamedComposed(payload UnionPayload) error {
	event_ := &payload
	return ((*_bindings.ChannelProxy)(p)).Send(ComposedProtocolOnNamedComposedOrdinal, event_)
}

const (
	MainProtocolOneWayAnonComposedOrdinal           uint64 = 0x6e7a205bdad7941f
	MainProtocolTwoWayAnonComposedOrdinal           uint64 = 0x7083713dee9435f4
	MainProtocolTwoWayAnonComposedWithErrorOrdinal  uint64 = 0x4fd32c5e2ffa6828
	MainProtocolOnAnonComposedOrdinal               uint64 = 0x49a6eee3a0300e28
	MainProtocolOneWayNamedComposedOrdinal          uint64 = 0x101636a8fa3e69b8
	MainProtocolTwoWayNamedComposedOrdinal          uint64 = 0x45b4d3d31b374054
	MainProtocolTwoWayNamedComposedWithErrorOrdinal uint64 = 0x450531e2d20c52ef
	MainProtocolOnNamedComposedOrdinal              uint64 = 0x17c4edb4a4a36d7b
	MainProtocolOneWayLocalOrdinal                  uint64 = 0x3954b4c6b80956c1
	MainProtocolTwoWayLocalOrdinal                  uint64 = 0x26998b4c1e8a9a57
	MainProtocolTwoWayLocalWithErrorOrdinal         uint64 = 0x4a7bf9ce881afde7
	MainProtocolOnLocalOrdinal                      uint64 = 0x71e90a3d364d2e8d
	MainProtocolOneWayAnonOrdinal                   uint64 = 0x774bf445f584ce2c
	MainProtocolTwoWayAnonOrdinal                   uint64 = 0x3fd7ad8e52b07e2e
	MainProtocolTwoWayAnonWithErrorOrdinal          uint64 = 0x1d33061a424eb245
	MainProtocolOnAnonOrdinal                       uint64 = 0xd8fa6d0f5fabb94
)

type MainProtocolWithCtxInterface _bindings.ChannelProxy

func (p *MainProtocolWithCtxInterface) OneWayAnonComposed(ctx_ _bindings.Context, payload ComposedProtocolOneWayAnonComposedRequest) error {
	req_ := &payload
	err_ := ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOneWayAnonComposedOrdinal, req_)
	return err_
}

func (p *MainProtocolWithCtxInterface) TwoWayAnonComposed(ctx_ _bindings.Context, payload ComposedProtocolTwoWayAnonComposedRequest) (ComposedProtocolTwoWayAnonComposedResponse, error) {
	req_ := &payload
	resp_ := &ComposedProtocolTwoWayAnonComposedResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayAnonComposedOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *MainProtocolWithCtxInterface) TwoWayAnonComposedWithError(ctx_ _bindings.Context, payload ComposedProtocolTwoWayAnonComposedWithErrorRequest) (ComposedProtocolTwoWayAnonComposedWithErrorResult, error) {
	req_ := &payload
	resp_ := &ComposedProtocolTwoWayAnonComposedWithErrorResult{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayAnonComposedWithErrorOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *MainProtocolWithCtxInterface) ExpectOnAnonComposed(ctx_ _bindings.Context) (ComposedProtocolOnAnonComposedRequest, error) {
	resp_ := &ComposedProtocolOnAnonComposedRequest{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnAnonComposedOrdinal, resp_)
	return (*resp_), err_
}

func (p *MainProtocolWithCtxInterface) OneWayNamedComposed(ctx_ _bindings.Context, payload TablePayload) error {
	req_ := &payload
	err_ := ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOneWayNamedComposedOrdinal, req_)
	return err_
}

func (p *MainProtocolWithCtxInterface) TwoWayNamedComposed(ctx_ _bindings.Context, payload UnionPayload) (TablePayload, error) {
	req_ := &payload
	resp_ := &TablePayload{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayNamedComposedOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *MainProtocolWithCtxInterface) TwoWayNamedComposedWithError(ctx_ _bindings.Context, payload TablePayload) (ComposedProtocolTwoWayNamedComposedWithErrorResult, error) {
	req_ := &payload
	resp_ := &ComposedProtocolTwoWayNamedComposedWithErrorResult{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayNamedComposedWithErrorOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *MainProtocolWithCtxInterface) ExpectOnNamedComposed(ctx_ _bindings.Context) (UnionPayload, error) {
	resp_ := &UnionPayload{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnNamedComposedOrdinal, resp_)
	return (*resp_), err_
}

func (p *MainProtocolWithCtxInterface) OneWayLocal(ctx_ _bindings.Context, payload TablePayload) error {
	req_ := &payload
	err_ := ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOneWayLocalOrdinal, req_)
	return err_
}

func (p *MainProtocolWithCtxInterface) TwoWayLocal(ctx_ _bindings.Context, payload UnionPayload) (TablePayload, error) {
	req_ := &payload
	resp_ := &TablePayload{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayLocalOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *MainProtocolWithCtxInterface) TwoWayLocalWithError(ctx_ _bindings.Context, payload TablePayload) (MainProtocolTwoWayLocalWithErrorResult, error) {
	req_ := &payload
	resp_ := &MainProtocolTwoWayLocalWithErrorResult{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayLocalWithErrorOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *MainProtocolWithCtxInterface) ExpectOnLocal(ctx_ _bindings.Context) (UnionPayload, error) {
	resp_ := &UnionPayload{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnLocalOrdinal, resp_)
	return (*resp_), err_
}

func (p *MainProtocolWithCtxInterface) OneWayAnon(ctx_ _bindings.Context, payload MainProtocolOneWayAnonRequest) error {
	req_ := &payload
	err_ := ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOneWayAnonOrdinal, req_)
	return err_
}

func (p *MainProtocolWithCtxInterface) TwoWayAnon(ctx_ _bindings.Context, payload MainProtocolTwoWayAnonRequest) (MainProtocolTwoWayAnonResponse, error) {
	req_ := &payload
	resp_ := &MainProtocolTwoWayAnonResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayAnonOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *MainProtocolWithCtxInterface) TwoWayAnonWithError(ctx_ _bindings.Context, payload MainProtocolTwoWayAnonWithErrorRequest) (MainProtocolTwoWayAnonWithErrorResult, error) {
	req_ := &payload
	resp_ := &MainProtocolTwoWayAnonWithErrorResult{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayAnonWithErrorOrdinal, req_, resp_)
	return (*resp_), err_
}

func (p *MainProtocolWithCtxInterface) ExpectOnAnon(ctx_ _bindings.Context) (MainProtocolOnAnonRequest, error) {
	resp_ := &MainProtocolOnAnonRequest{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnAnonOrdinal, resp_)
	return (*resp_), err_
}

type MainProtocolWithCtx interface {
	OneWayAnonComposed(ctx_ _bindings.Context, payload ComposedProtocolOneWayAnonComposedRequest) error
	TwoWayAnonComposed(ctx_ _bindings.Context, payload ComposedProtocolTwoWayAnonComposedRequest) (ComposedProtocolTwoWayAnonComposedResponse, error)
	TwoWayAnonComposedWithError(ctx_ _bindings.Context, payload ComposedProtocolTwoWayAnonComposedWithErrorRequest) (ComposedProtocolTwoWayAnonComposedWithErrorResult, error)
	OneWayNamedComposed(ctx_ _bindings.Context, payload TablePayload) error
	TwoWayNamedComposed(ctx_ _bindings.Context, payload UnionPayload) (TablePayload, error)
	TwoWayNamedComposedWithError(ctx_ _bindings.Context, payload TablePayload) (ComposedProtocolTwoWayNamedComposedWithErrorResult, error)
	OneWayLocal(ctx_ _bindings.Context, payload TablePayload) error
	TwoWayLocal(ctx_ _bindings.Context, payload UnionPayload) (TablePayload, error)
	TwoWayLocalWithError(ctx_ _bindings.Context, payload TablePayload) (MainProtocolTwoWayLocalWithErrorResult, error)
	OneWayAnon(ctx_ _bindings.Context, payload MainProtocolOneWayAnonRequest) error
	TwoWayAnon(ctx_ _bindings.Context, payload MainProtocolTwoWayAnonRequest) (MainProtocolTwoWayAnonResponse, error)
	TwoWayAnonWithError(ctx_ _bindings.Context, payload MainProtocolTwoWayAnonWithErrorRequest) (MainProtocolTwoWayAnonWithErrorResult, error)
}
type MainProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewMainProtocolWithCtxInterfaceRequest() (MainProtocolWithCtxInterfaceRequest, *MainProtocolWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return MainProtocolWithCtxInterfaceRequest(req), (*MainProtocolWithCtxInterface)(cli), err
}

type MainProtocolWithCtxStub struct {
	Impl MainProtocolWithCtx
}

func (s_ *MainProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case MainProtocolOneWayAnonComposedOrdinal:
		in_ := &ComposedProtocolOneWayAnonComposedRequest{}
		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.OneWayAnonComposed(args_.Ctx, (*in_))
		return nil, false, err_
	case MainProtocolTwoWayAnonComposedOrdinal:
		in_ := &ComposedProtocolTwoWayAnonComposedRequest{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayAnonComposed(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	case MainProtocolTwoWayAnonComposedWithErrorOrdinal:
		in_ := &ComposedProtocolTwoWayAnonComposedWithErrorRequest{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayAnonComposedWithError(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	case MainProtocolOneWayNamedComposedOrdinal:
		in_ := &TablePayload{}
		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.OneWayNamedComposed(args_.Ctx, (*in_))
		return nil, false, err_
	case MainProtocolTwoWayNamedComposedOrdinal:
		in_ := &UnionPayload{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayNamedComposed(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	case MainProtocolTwoWayNamedComposedWithErrorOrdinal:
		in_ := &TablePayload{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayNamedComposedWithError(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	case MainProtocolOneWayLocalOrdinal:
		in_ := &TablePayload{}
		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.OneWayLocal(args_.Ctx, (*in_))
		return nil, false, err_
	case MainProtocolTwoWayLocalOrdinal:
		in_ := &UnionPayload{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayLocal(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	case MainProtocolTwoWayLocalWithErrorOrdinal:
		in_ := &TablePayload{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayLocalWithError(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	case MainProtocolOneWayAnonOrdinal:
		in_ := &MainProtocolOneWayAnonRequest{}
		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.OneWayAnon(args_.Ctx, (*in_))
		return nil, false, err_
	case MainProtocolTwoWayAnonOrdinal:
		in_ := &MainProtocolTwoWayAnonRequest{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayAnon(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	case MainProtocolTwoWayAnonWithErrorOrdinal:
		in_ := &MainProtocolTwoWayAnonWithErrorRequest{}
		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_
		}
		payload, err_ := s_.Impl.TwoWayAnonWithError(args_.Ctx, (*in_))
		out_ := &payload
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type MainProtocolEventProxy _bindings.ChannelProxy

func (p *MainProtocolEventProxy) OnAnonComposed(payload ComposedProtocolOnAnonComposedRequest) error {
	event_ := &payload
	return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnAnonComposedOrdinal, event_)
}
func (p *MainProtocolEventProxy) OnNamedComposed(payload UnionPayload) error {
	event_ := &payload
	return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnNamedComposedOrdinal, event_)
}
func (p *MainProtocolEventProxy) OnLocal(payload UnionPayload) error {
	event_ := &payload
	return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnLocalOrdinal, event_)
}
func (p *MainProtocolEventProxy) OnAnon(payload MainProtocolOnAnonRequest) error {
	event_ := &payload
	return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnAnonOrdinal, event_)
}