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

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

// fidl_experiment = output_index_json

package union

import (
	_bindings "syscall/zx/fidl"
)

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

var _mEmpty = _bindings.CreateLazyMarshaler(Empty{})

func (msg *Empty) Marshaler() _bindings.Marshaler {
	return _mEmpty
}

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

var _mNullableUnionStruct = _bindings.CreateLazyMarshaler(NullableUnionStruct{})

func (msg *NullableUnionStruct) Marshaler() _bindings.Marshaler {
	return _mNullableUnionStruct
}

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

var _mPasta = _bindings.CreateLazyMarshaler(Pasta{})

func (msg *Pasta) Marshaler() _bindings.Marshaler {
	return _mPasta
}

type Pizza struct {
	_        struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Toppings []string `fidl_offset_v2:"0" fidl_bounds:",16"`
}

var _mPizza = _bindings.CreateLazyMarshaler(Pizza{})

func (msg *Pizza) Marshaler() _bindings.Marshaler {
	return _mPizza
}

type StructWithNullableUnion struct {
	_  struct{}          `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	X1 *OlderSimpleUnion `fidl_offset_v2:"0"`
}

var _mStructWithNullableUnion = _bindings.CreateLazyMarshaler(StructWithNullableUnion{})

func (msg *StructWithNullableUnion) Marshaler() _bindings.Marshaler {
	return _mStructWithNullableUnion
}

type TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse struct {
	_  struct{}         `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Xu OlderSimpleUnion `fidl_offset_v2:"0"`
}

var _mTestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse = _bindings.CreateLazyMarshaler(TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse{})

func (msg *TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse) Marshaler() _bindings.Marshaler {
	return _mTestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse
}

type TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse struct {
	_  struct{}           `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
	Xu StrictBoundedUnion `fidl_offset_v2:"0"`
}

var _mTestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse = _bindings.CreateLazyMarshaler(TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse{})

func (msg *TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse) Marshaler() _bindings.Marshaler {
	return _mTestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse
}

type UnionSandwich struct {
	_ struct{}              `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
	A uint32                `fidl_offset_v2:"0"`
	U ExplicitFlexibleUnion `fidl_offset_v2:"8"`
	B uint32                `fidl_offset_v2:"24"`
}

var _mUnionSandwich = _bindings.CreateLazyMarshaler(UnionSandwich{})

func (msg *UnionSandwich) Marshaler() _bindings.Marshaler {
	return _mUnionSandwich
}

type I_emptyFlexibleUnionTag uint64

const (
	EmptyFlexibleUnion_unknownData = 0 // 0x00000000
)

type EmptyFlexibleUnion struct {
	I_emptyFlexibleUnionTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData           interface{}
}

var _mEmptyFlexibleUnion = _bindings.CreateLazyMarshaler(EmptyFlexibleUnion{})

func (msg *EmptyFlexibleUnion) Marshaler() _bindings.Marshaler {
	return _mEmptyFlexibleUnion
}

func (_m *EmptyFlexibleUnion) reset() {
	switch _m.I_emptyFlexibleUnionTag {
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *EmptyFlexibleUnion) Which() I_emptyFlexibleUnionTag {
	switch _m.I_emptyFlexibleUnionTag {
	default:
		return EmptyFlexibleUnion_unknownData
	}
}

func (_m *EmptyFlexibleUnion) Ordinal() uint64 {
	return uint64(_m.I_emptyFlexibleUnionTag)
}
func (_m *EmptyFlexibleUnion) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_explicitFlexibleUnionTag uint64

const (
	ExplicitFlexibleUnion_unknownData = 0 // 0x00000000
	ExplicitFlexibleUnionI            = 1 // 0x00000001
	ExplicitFlexibleUnionF            = 4 // 0x00000004
)

type ExplicitFlexibleUnion struct {
	I_explicitFlexibleUnionTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData              interface{}
	I                          int64   `fidl_ordinal:"1"`
	F                          float32 `fidl_ordinal:"4"`
}

var _mExplicitFlexibleUnion = _bindings.CreateLazyMarshaler(ExplicitFlexibleUnion{})

func (msg *ExplicitFlexibleUnion) Marshaler() _bindings.Marshaler {
	return _mExplicitFlexibleUnion
}

func (_m *ExplicitFlexibleUnion) reset() {
	switch _m.I_explicitFlexibleUnionTag {
	case 1:
		var _zeroed int64
		_m.I = _zeroed
	case 4:
		var _zeroed float32
		_m.F = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *ExplicitFlexibleUnion) Which() I_explicitFlexibleUnionTag {
	switch _m.I_explicitFlexibleUnionTag {
	case 1:
		return ExplicitFlexibleUnionI
	case 4:
		return ExplicitFlexibleUnionF
	default:
		return ExplicitFlexibleUnion_unknownData
	}
}

func (_m *ExplicitFlexibleUnion) Ordinal() uint64 {
	return uint64(_m.I_explicitFlexibleUnionTag)
}

func (_m *ExplicitFlexibleUnion) SetI(i int64) {
	_m.reset()
	_m.I_explicitFlexibleUnionTag = ExplicitFlexibleUnionI
	_m.I = i
}

func ExplicitFlexibleUnionWithI(i int64) ExplicitFlexibleUnion {
	var _u ExplicitFlexibleUnion
	_u.SetI(i)
	return _u
}

func (_m *ExplicitFlexibleUnion) SetF(f float32) {
	_m.reset()
	_m.I_explicitFlexibleUnionTag = ExplicitFlexibleUnionF
	_m.F = f
}

func ExplicitFlexibleUnionWithF(f float32) ExplicitFlexibleUnion {
	var _u ExplicitFlexibleUnion
	_u.SetF(f)
	return _u
}
func (_m *ExplicitFlexibleUnion) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_explicitFooTag uint64

const (
	ExplicitFoo_unknownData = 0 // 0x00000000
	ExplicitFooI            = 1 // 0x00000001
	ExplicitFooS            = 2 // 0x00000002
)

type ExplicitFoo struct {
	I_explicitFooTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData    interface{}
	I                int32  `fidl_ordinal:"1"`
	S                string `fidl_bounds:"" fidl_ordinal:"2"`
}

var _mExplicitFoo = _bindings.CreateLazyMarshaler(ExplicitFoo{})

func (msg *ExplicitFoo) Marshaler() _bindings.Marshaler {
	return _mExplicitFoo
}

func (_m *ExplicitFoo) reset() {
	switch _m.I_explicitFooTag {
	case 1:
		var _zeroed int32
		_m.I = _zeroed
	case 2:
		var _zeroed string
		_m.S = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *ExplicitFoo) Which() I_explicitFooTag {
	switch _m.I_explicitFooTag {
	case 1:
		return ExplicitFooI
	case 2:
		return ExplicitFooS
	default:
		return ExplicitFoo_unknownData
	}
}

func (_m *ExplicitFoo) Ordinal() uint64 {
	return uint64(_m.I_explicitFooTag)
}

func (_m *ExplicitFoo) SetI(i int32) {
	_m.reset()
	_m.I_explicitFooTag = ExplicitFooI
	_m.I = i
}

func ExplicitFooWithI(i int32) ExplicitFoo {
	var _u ExplicitFoo
	_u.SetI(i)
	return _u
}

func (_m *ExplicitFoo) SetS(s string) {
	_m.reset()
	_m.I_explicitFooTag = ExplicitFooS
	_m.S = s
}

func ExplicitFooWithS(s string) ExplicitFoo {
	var _u ExplicitFoo
	_u.SetS(s)
	return _u
}
func (_m *ExplicitFoo) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_explicitPizzaOrPastaTag uint64

const (
	ExplicitPizzaOrPastaPizza = 1 // 0x00000001
	ExplicitPizzaOrPastaPasta = 4 // 0x00000004
)

type ExplicitPizzaOrPasta struct {
	I_explicitPizzaOrPastaTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Pizza                     Pizza `fidl_ordinal:"1"`
	Pasta                     Pasta `fidl_ordinal:"4"`
}

var _mExplicitPizzaOrPasta = _bindings.CreateLazyMarshaler(ExplicitPizzaOrPasta{})

func (msg *ExplicitPizzaOrPasta) Marshaler() _bindings.Marshaler {
	return _mExplicitPizzaOrPasta
}

func (_m *ExplicitPizzaOrPasta) reset() {
	switch _m.I_explicitPizzaOrPastaTag {
	case 1:
		var _zeroed Pizza
		_m.Pizza = _zeroed
	case 4:
		var _zeroed Pasta
		_m.Pasta = _zeroed
	}
}

func (_m *ExplicitPizzaOrPasta) Which() I_explicitPizzaOrPastaTag {
	return _m.I_explicitPizzaOrPastaTag
}

func (_m *ExplicitPizzaOrPasta) Ordinal() uint64 {
	return uint64(_m.I_explicitPizzaOrPastaTag)
}

func (_m *ExplicitPizzaOrPasta) SetPizza(pizza Pizza) {
	_m.reset()
	_m.I_explicitPizzaOrPastaTag = ExplicitPizzaOrPastaPizza
	_m.Pizza = pizza
}

func ExplicitPizzaOrPastaWithPizza(pizza Pizza) ExplicitPizzaOrPasta {
	var _u ExplicitPizzaOrPasta
	_u.SetPizza(pizza)
	return _u
}

func (_m *ExplicitPizzaOrPasta) SetPasta(pasta Pasta) {
	_m.reset()
	_m.I_explicitPizzaOrPastaTag = ExplicitPizzaOrPastaPasta
	_m.Pasta = pasta
}

func ExplicitPizzaOrPastaWithPasta(pasta Pasta) ExplicitPizzaOrPasta {
	var _u ExplicitPizzaOrPasta
	_u.SetPasta(pasta)
	return _u
}

type I_explicitStrictFooTag uint64

const (
	ExplicitStrictFooI = 2 // 0x00000002
	ExplicitStrictFooS = 3 // 0x00000003
)

type ExplicitStrictFoo struct {
	I_explicitStrictFooTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I                      int32  `fidl_ordinal:"2"`
	S                      string `fidl_bounds:"" fidl_ordinal:"3"`
}

var _mExplicitStrictFoo = _bindings.CreateLazyMarshaler(ExplicitStrictFoo{})

func (msg *ExplicitStrictFoo) Marshaler() _bindings.Marshaler {
	return _mExplicitStrictFoo
}

func (_m *ExplicitStrictFoo) reset() {
	switch _m.I_explicitStrictFooTag {
	case 2:
		var _zeroed int32
		_m.I = _zeroed
	case 3:
		var _zeroed string
		_m.S = _zeroed
	}
}

func (_m *ExplicitStrictFoo) Which() I_explicitStrictFooTag {
	return _m.I_explicitStrictFooTag
}

func (_m *ExplicitStrictFoo) Ordinal() uint64 {
	return uint64(_m.I_explicitStrictFooTag)
}

func (_m *ExplicitStrictFoo) SetI(i int32) {
	_m.reset()
	_m.I_explicitStrictFooTag = ExplicitStrictFooI
	_m.I = i
}

func ExplicitStrictFooWithI(i int32) ExplicitStrictFoo {
	var _u ExplicitStrictFoo
	_u.SetI(i)
	return _u
}

func (_m *ExplicitStrictFoo) SetS(s string) {
	_m.reset()
	_m.I_explicitStrictFooTag = ExplicitStrictFooS
	_m.S = s
}

func ExplicitStrictFooWithS(s string) ExplicitStrictFoo {
	var _u ExplicitStrictFoo
	_u.SetS(s)
	return _u
}

type I_explicitUnionTag uint64

const (
	ExplicitUnionPrimitive              = 1 // 0x00000001
	ExplicitUnionStringNeedsConstructor = 3 // 0x00000003
)

type ExplicitUnion struct {
	I_explicitUnionTag     `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Primitive              int32  `fidl_ordinal:"1"`
	StringNeedsConstructor string `fidl_bounds:"" fidl_ordinal:"3"`
}

var _mExplicitUnion = _bindings.CreateLazyMarshaler(ExplicitUnion{})

func (msg *ExplicitUnion) Marshaler() _bindings.Marshaler {
	return _mExplicitUnion
}

func (_m *ExplicitUnion) reset() {
	switch _m.I_explicitUnionTag {
	case 1:
		var _zeroed int32
		_m.Primitive = _zeroed
	case 3:
		var _zeroed string
		_m.StringNeedsConstructor = _zeroed
	}
}

func (_m *ExplicitUnion) Which() I_explicitUnionTag {
	return _m.I_explicitUnionTag
}

func (_m *ExplicitUnion) Ordinal() uint64 {
	return uint64(_m.I_explicitUnionTag)
}

func (_m *ExplicitUnion) SetPrimitive(primitive int32) {
	_m.reset()
	_m.I_explicitUnionTag = ExplicitUnionPrimitive
	_m.Primitive = primitive
}

func ExplicitUnionWithPrimitive(primitive int32) ExplicitUnion {
	var _u ExplicitUnion
	_u.SetPrimitive(primitive)
	return _u
}

func (_m *ExplicitUnion) SetStringNeedsConstructor(stringNeedsConstructor string) {
	_m.reset()
	_m.I_explicitUnionTag = ExplicitUnionStringNeedsConstructor
	_m.StringNeedsConstructor = stringNeedsConstructor
}

func ExplicitUnionWithStringNeedsConstructor(stringNeedsConstructor string) ExplicitUnion {
	var _u ExplicitUnion
	_u.SetStringNeedsConstructor(stringNeedsConstructor)
	return _u
}

type I_fieldCollisionTag uint64

const (
	FieldCollisionFieldCollisionTag = 1 // 0x00000001
)

type FieldCollision struct {
	I_fieldCollisionTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	FieldCollisionTag   int32 `fidl_ordinal:"1"`
}

var _mFieldCollision = _bindings.CreateLazyMarshaler(FieldCollision{})

func (msg *FieldCollision) Marshaler() _bindings.Marshaler {
	return _mFieldCollision
}

func (_m *FieldCollision) reset() {
	switch _m.I_fieldCollisionTag {
	case 1:
		var _zeroed int32
		_m.FieldCollisionTag = _zeroed
	}
}

func (_m *FieldCollision) Which() I_fieldCollisionTag {
	return _m.I_fieldCollisionTag
}

func (_m *FieldCollision) Ordinal() uint64 {
	return uint64(_m.I_fieldCollisionTag)
}

func (_m *FieldCollision) SetFieldCollisionTag(fieldCollisionTag int32) {
	_m.reset()
	_m.I_fieldCollisionTag = FieldCollisionFieldCollisionTag
	_m.FieldCollisionTag = fieldCollisionTag
}

func FieldCollisionWithFieldCollisionTag(fieldCollisionTag int32) FieldCollision {
	var _u FieldCollision
	_u.SetFieldCollisionTag(fieldCollisionTag)
	return _u
}

type I_flexibleFooTag uint64

const (
	FlexibleFoo_unknownData = 0 // 0x00000000
	FlexibleFooS            = 1 // 0x00000001
	FlexibleFooI            = 2 // 0x00000002
)

type FlexibleFoo struct {
	I_flexibleFooTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData    interface{}
	S                string `fidl_bounds:"" fidl_ordinal:"1"`
	I                int32  `fidl_ordinal:"2"`
}

var _mFlexibleFoo = _bindings.CreateLazyMarshaler(FlexibleFoo{})

func (msg *FlexibleFoo) Marshaler() _bindings.Marshaler {
	return _mFlexibleFoo
}

func (_m *FlexibleFoo) reset() {
	switch _m.I_flexibleFooTag {
	case 1:
		var _zeroed string
		_m.S = _zeroed
	case 2:
		var _zeroed int32
		_m.I = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *FlexibleFoo) Which() I_flexibleFooTag {
	switch _m.I_flexibleFooTag {
	case 1:
		return FlexibleFooS
	case 2:
		return FlexibleFooI
	default:
		return FlexibleFoo_unknownData
	}
}

func (_m *FlexibleFoo) Ordinal() uint64 {
	return uint64(_m.I_flexibleFooTag)
}

func (_m *FlexibleFoo) SetS(s string) {
	_m.reset()
	_m.I_flexibleFooTag = FlexibleFooS
	_m.S = s
}

func FlexibleFooWithS(s string) FlexibleFoo {
	var _u FlexibleFoo
	_u.SetS(s)
	return _u
}

func (_m *FlexibleFoo) SetI(i int32) {
	_m.reset()
	_m.I_flexibleFooTag = FlexibleFooI
	_m.I = i
}

func FlexibleFooWithI(i int32) FlexibleFoo {
	var _u FlexibleFoo
	_u.SetI(i)
	return _u
}
func (_m *FlexibleFoo) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_flexiblePizzaOrPastaTag uint64

const (
	FlexiblePizzaOrPasta_unknownData = 0 // 0x00000000
	FlexiblePizzaOrPastaPizza        = 1 // 0x00000001
	FlexiblePizzaOrPastaPasta        = 2 // 0x00000002
)

type FlexiblePizzaOrPasta struct {
	I_flexiblePizzaOrPastaTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData             interface{}
	Pizza                     Pizza `fidl_ordinal:"1"`
	Pasta                     Pasta `fidl_ordinal:"2"`
}

var _mFlexiblePizzaOrPasta = _bindings.CreateLazyMarshaler(FlexiblePizzaOrPasta{})

func (msg *FlexiblePizzaOrPasta) Marshaler() _bindings.Marshaler {
	return _mFlexiblePizzaOrPasta
}

func (_m *FlexiblePizzaOrPasta) reset() {
	switch _m.I_flexiblePizzaOrPastaTag {
	case 1:
		var _zeroed Pizza
		_m.Pizza = _zeroed
	case 2:
		var _zeroed Pasta
		_m.Pasta = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *FlexiblePizzaOrPasta) Which() I_flexiblePizzaOrPastaTag {
	switch _m.I_flexiblePizzaOrPastaTag {
	case 1:
		return FlexiblePizzaOrPastaPizza
	case 2:
		return FlexiblePizzaOrPastaPasta
	default:
		return FlexiblePizzaOrPasta_unknownData
	}
}

func (_m *FlexiblePizzaOrPasta) Ordinal() uint64 {
	return uint64(_m.I_flexiblePizzaOrPastaTag)
}

func (_m *FlexiblePizzaOrPasta) SetPizza(pizza Pizza) {
	_m.reset()
	_m.I_flexiblePizzaOrPastaTag = FlexiblePizzaOrPastaPizza
	_m.Pizza = pizza
}

func FlexiblePizzaOrPastaWithPizza(pizza Pizza) FlexiblePizzaOrPasta {
	var _u FlexiblePizzaOrPasta
	_u.SetPizza(pizza)
	return _u
}

func (_m *FlexiblePizzaOrPasta) SetPasta(pasta Pasta) {
	_m.reset()
	_m.I_flexiblePizzaOrPastaTag = FlexiblePizzaOrPastaPasta
	_m.Pasta = pasta
}

func FlexiblePizzaOrPastaWithPasta(pasta Pasta) FlexiblePizzaOrPasta {
	var _u FlexiblePizzaOrPasta
	_u.SetPasta(pasta)
	return _u
}
func (_m *FlexiblePizzaOrPasta) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_flexibleUnionTag uint64

const (
	FlexibleUnion_unknownData                     = 0 // 0x00000000
	FlexibleUnionPrimitive                        = 1 // 0x00000001
	FlexibleUnionStringNeedsConstructor           = 2 // 0x00000002
	FlexibleUnionVectorStringAlsoNeedsConstructor = 3 // 0x00000003
)

type FlexibleUnion struct {
	I_flexibleUnionTag               `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData                    interface{}
	Primitive                        int32    `fidl_ordinal:"1"`
	StringNeedsConstructor           string   `fidl_bounds:"" fidl_ordinal:"2"`
	VectorStringAlsoNeedsConstructor []string `fidl_bounds:"" fidl_ordinal:"3"`
}

var _mFlexibleUnion = _bindings.CreateLazyMarshaler(FlexibleUnion{})

func (msg *FlexibleUnion) Marshaler() _bindings.Marshaler {
	return _mFlexibleUnion
}

func (_m *FlexibleUnion) reset() {
	switch _m.I_flexibleUnionTag {
	case 1:
		var _zeroed int32
		_m.Primitive = _zeroed
	case 2:
		var _zeroed string
		_m.StringNeedsConstructor = _zeroed
	case 3:
		var _zeroed []string
		_m.VectorStringAlsoNeedsConstructor = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *FlexibleUnion) Which() I_flexibleUnionTag {
	switch _m.I_flexibleUnionTag {
	case 1:
		return FlexibleUnionPrimitive
	case 2:
		return FlexibleUnionStringNeedsConstructor
	case 3:
		return FlexibleUnionVectorStringAlsoNeedsConstructor
	default:
		return FlexibleUnion_unknownData
	}
}

func (_m *FlexibleUnion) Ordinal() uint64 {
	return uint64(_m.I_flexibleUnionTag)
}

func (_m *FlexibleUnion) SetPrimitive(primitive int32) {
	_m.reset()
	_m.I_flexibleUnionTag = FlexibleUnionPrimitive
	_m.Primitive = primitive
}

func FlexibleUnionWithPrimitive(primitive int32) FlexibleUnion {
	var _u FlexibleUnion
	_u.SetPrimitive(primitive)
	return _u
}

func (_m *FlexibleUnion) SetStringNeedsConstructor(stringNeedsConstructor string) {
	_m.reset()
	_m.I_flexibleUnionTag = FlexibleUnionStringNeedsConstructor
	_m.StringNeedsConstructor = stringNeedsConstructor
}

func FlexibleUnionWithStringNeedsConstructor(stringNeedsConstructor string) FlexibleUnion {
	var _u FlexibleUnion
	_u.SetStringNeedsConstructor(stringNeedsConstructor)
	return _u
}

func (_m *FlexibleUnion) SetVectorStringAlsoNeedsConstructor(vectorStringAlsoNeedsConstructor []string) {
	_m.reset()
	_m.I_flexibleUnionTag = FlexibleUnionVectorStringAlsoNeedsConstructor
	_m.VectorStringAlsoNeedsConstructor = vectorStringAlsoNeedsConstructor
}

func FlexibleUnionWithVectorStringAlsoNeedsConstructor(vectorStringAlsoNeedsConstructor []string) FlexibleUnion {
	var _u FlexibleUnion
	_u.SetVectorStringAlsoNeedsConstructor(vectorStringAlsoNeedsConstructor)
	return _u
}
func (_m *FlexibleUnion) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_newerSimpleUnionTag uint64

const (
	NewerSimpleUnion_unknownData = 0 // 0x00000000
	NewerSimpleUnionI            = 1 // 0x00000001
	NewerSimpleUnionS            = 2 // 0x00000002
	NewerSimpleUnionV            = 3 // 0x00000003
)

type NewerSimpleUnion struct {
	I_newerSimpleUnionTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData         interface{}
	I                     int64    `fidl_ordinal:"1"`
	S                     string   `fidl_bounds:"" fidl_ordinal:"2"`
	V                     []string `fidl_bounds:"" fidl_ordinal:"3"`
}

var _mNewerSimpleUnion = _bindings.CreateLazyMarshaler(NewerSimpleUnion{})

func (msg *NewerSimpleUnion) Marshaler() _bindings.Marshaler {
	return _mNewerSimpleUnion
}

func (_m *NewerSimpleUnion) reset() {
	switch _m.I_newerSimpleUnionTag {
	case 1:
		var _zeroed int64
		_m.I = _zeroed
	case 2:
		var _zeroed string
		_m.S = _zeroed
	case 3:
		var _zeroed []string
		_m.V = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *NewerSimpleUnion) Which() I_newerSimpleUnionTag {
	switch _m.I_newerSimpleUnionTag {
	case 1:
		return NewerSimpleUnionI
	case 2:
		return NewerSimpleUnionS
	case 3:
		return NewerSimpleUnionV
	default:
		return NewerSimpleUnion_unknownData
	}
}

func (_m *NewerSimpleUnion) Ordinal() uint64 {
	return uint64(_m.I_newerSimpleUnionTag)
}

func (_m *NewerSimpleUnion) SetI(i int64) {
	_m.reset()
	_m.I_newerSimpleUnionTag = NewerSimpleUnionI
	_m.I = i
}

func NewerSimpleUnionWithI(i int64) NewerSimpleUnion {
	var _u NewerSimpleUnion
	_u.SetI(i)
	return _u
}

func (_m *NewerSimpleUnion) SetS(s string) {
	_m.reset()
	_m.I_newerSimpleUnionTag = NewerSimpleUnionS
	_m.S = s
}

func NewerSimpleUnionWithS(s string) NewerSimpleUnion {
	var _u NewerSimpleUnion
	_u.SetS(s)
	return _u
}

func (_m *NewerSimpleUnion) SetV(v []string) {
	_m.reset()
	_m.I_newerSimpleUnionTag = NewerSimpleUnionV
	_m.V = v
}

func NewerSimpleUnionWithV(v []string) NewerSimpleUnion {
	var _u NewerSimpleUnion
	_u.SetV(v)
	return _u
}
func (_m *NewerSimpleUnion) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_olderSimpleUnionTag uint64

const (
	OlderSimpleUnion_unknownData = 0 // 0x00000000
	OlderSimpleUnionI            = 1 // 0x00000001
	OlderSimpleUnionF            = 2 // 0x00000002
)

type OlderSimpleUnion struct {
	I_olderSimpleUnionTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData         interface{}
	I                     int64   `fidl_ordinal:"1"`
	F                     float32 `fidl_ordinal:"2"`
}

var _mOlderSimpleUnion = _bindings.CreateLazyMarshaler(OlderSimpleUnion{})

func (msg *OlderSimpleUnion) Marshaler() _bindings.Marshaler {
	return _mOlderSimpleUnion
}

func (_m *OlderSimpleUnion) reset() {
	switch _m.I_olderSimpleUnionTag {
	case 1:
		var _zeroed int64
		_m.I = _zeroed
	case 2:
		var _zeroed float32
		_m.F = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *OlderSimpleUnion) Which() I_olderSimpleUnionTag {
	switch _m.I_olderSimpleUnionTag {
	case 1:
		return OlderSimpleUnionI
	case 2:
		return OlderSimpleUnionF
	default:
		return OlderSimpleUnion_unknownData
	}
}

func (_m *OlderSimpleUnion) Ordinal() uint64 {
	return uint64(_m.I_olderSimpleUnionTag)
}

func (_m *OlderSimpleUnion) SetI(i int64) {
	_m.reset()
	_m.I_olderSimpleUnionTag = OlderSimpleUnionI
	_m.I = i
}

func OlderSimpleUnionWithI(i int64) OlderSimpleUnion {
	var _u OlderSimpleUnion
	_u.SetI(i)
	return _u
}

func (_m *OlderSimpleUnion) SetF(f float32) {
	_m.reset()
	_m.I_olderSimpleUnionTag = OlderSimpleUnionF
	_m.F = f
}

func OlderSimpleUnionWithF(f float32) OlderSimpleUnion {
	var _u OlderSimpleUnion
	_u.SetF(f)
	return _u
}
func (_m *OlderSimpleUnion) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_pizzaOrPastaTag uint64

const (
	PizzaOrPastaPizza = 1 // 0x00000001
	PizzaOrPastaPasta = 2 // 0x00000002
)

type PizzaOrPasta struct {
	I_pizzaOrPastaTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Pizza             Pizza `fidl_ordinal:"1"`
	Pasta             Pasta `fidl_ordinal:"2"`
}

var _mPizzaOrPasta = _bindings.CreateLazyMarshaler(PizzaOrPasta{})

func (msg *PizzaOrPasta) Marshaler() _bindings.Marshaler {
	return _mPizzaOrPasta
}

func (_m *PizzaOrPasta) reset() {
	switch _m.I_pizzaOrPastaTag {
	case 1:
		var _zeroed Pizza
		_m.Pizza = _zeroed
	case 2:
		var _zeroed Pasta
		_m.Pasta = _zeroed
	}
}

func (_m *PizzaOrPasta) Which() I_pizzaOrPastaTag {
	return _m.I_pizzaOrPastaTag
}

func (_m *PizzaOrPasta) Ordinal() uint64 {
	return uint64(_m.I_pizzaOrPastaTag)
}

func (_m *PizzaOrPasta) SetPizza(pizza Pizza) {
	_m.reset()
	_m.I_pizzaOrPastaTag = PizzaOrPastaPizza
	_m.Pizza = pizza
}

func PizzaOrPastaWithPizza(pizza Pizza) PizzaOrPasta {
	var _u PizzaOrPasta
	_u.SetPizza(pizza)
	return _u
}

func (_m *PizzaOrPasta) SetPasta(pasta Pasta) {
	_m.reset()
	_m.I_pizzaOrPastaTag = PizzaOrPastaPasta
	_m.Pasta = pasta
}

func PizzaOrPastaWithPasta(pasta Pasta) PizzaOrPasta {
	var _u PizzaOrPasta
	_u.SetPasta(pasta)
	return _u
}

type I_reverseOrdinalUnionTag uint64

const (
	ReverseOrdinalUnionFirst  = 1 // 0x00000001
	ReverseOrdinalUnionSecond = 2 // 0x00000002
)

type ReverseOrdinalUnion struct {
	I_reverseOrdinalUnionTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	First                    uint32 `fidl_ordinal:"1"`
	Second                   uint32 `fidl_ordinal:"2"`
}

var _mReverseOrdinalUnion = _bindings.CreateLazyMarshaler(ReverseOrdinalUnion{})

func (msg *ReverseOrdinalUnion) Marshaler() _bindings.Marshaler {
	return _mReverseOrdinalUnion
}

func (_m *ReverseOrdinalUnion) reset() {
	switch _m.I_reverseOrdinalUnionTag {
	case 1:
		var _zeroed uint32
		_m.First = _zeroed
	case 2:
		var _zeroed uint32
		_m.Second = _zeroed
	}
}

func (_m *ReverseOrdinalUnion) Which() I_reverseOrdinalUnionTag {
	return _m.I_reverseOrdinalUnionTag
}

func (_m *ReverseOrdinalUnion) Ordinal() uint64 {
	return uint64(_m.I_reverseOrdinalUnionTag)
}

func (_m *ReverseOrdinalUnion) SetFirst(first uint32) {
	_m.reset()
	_m.I_reverseOrdinalUnionTag = ReverseOrdinalUnionFirst
	_m.First = first
}

func ReverseOrdinalUnionWithFirst(first uint32) ReverseOrdinalUnion {
	var _u ReverseOrdinalUnion
	_u.SetFirst(first)
	return _u
}

func (_m *ReverseOrdinalUnion) SetSecond(second uint32) {
	_m.reset()
	_m.I_reverseOrdinalUnionTag = ReverseOrdinalUnionSecond
	_m.Second = second
}

func ReverseOrdinalUnionWithSecond(second uint32) ReverseOrdinalUnion {
	var _u ReverseOrdinalUnion
	_u.SetSecond(second)
	return _u
}

type I_strictBoundedUnionTag uint64

const (
	StrictBoundedUnionV = 1 // 0x00000001
)

type StrictBoundedUnion struct {
	I_strictBoundedUnionTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	V                       []uint8 `fidl_bounds:"10" fidl_ordinal:"1"`
}

var _mStrictBoundedUnion = _bindings.CreateLazyMarshaler(StrictBoundedUnion{})

func (msg *StrictBoundedUnion) Marshaler() _bindings.Marshaler {
	return _mStrictBoundedUnion
}

func (_m *StrictBoundedUnion) reset() {
	switch _m.I_strictBoundedUnionTag {
	case 1:
		var _zeroed []uint8
		_m.V = _zeroed
	}
}

func (_m *StrictBoundedUnion) Which() I_strictBoundedUnionTag {
	return _m.I_strictBoundedUnionTag
}

func (_m *StrictBoundedUnion) Ordinal() uint64 {
	return uint64(_m.I_strictBoundedUnionTag)
}

func (_m *StrictBoundedUnion) SetV(v []uint8) {
	_m.reset()
	_m.I_strictBoundedUnionTag = StrictBoundedUnionV
	_m.V = v
}

func StrictBoundedUnionWithV(v []uint8) StrictBoundedUnion {
	var _u StrictBoundedUnion
	_u.SetV(v)
	return _u
}

type I_strictFooTag uint64

const (
	StrictFooS = 1 // 0x00000001
	StrictFooI = 2 // 0x00000002
)

type StrictFoo struct {
	I_strictFooTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	S              string `fidl_bounds:"" fidl_ordinal:"1"`
	I              int32  `fidl_ordinal:"2"`
}

var _mStrictFoo = _bindings.CreateLazyMarshaler(StrictFoo{})

func (msg *StrictFoo) Marshaler() _bindings.Marshaler {
	return _mStrictFoo
}

func (_m *StrictFoo) reset() {
	switch _m.I_strictFooTag {
	case 1:
		var _zeroed string
		_m.S = _zeroed
	case 2:
		var _zeroed int32
		_m.I = _zeroed
	}
}

func (_m *StrictFoo) Which() I_strictFooTag {
	return _m.I_strictFooTag
}

func (_m *StrictFoo) Ordinal() uint64 {
	return uint64(_m.I_strictFooTag)
}

func (_m *StrictFoo) SetS(s string) {
	_m.reset()
	_m.I_strictFooTag = StrictFooS
	_m.S = s
}

func StrictFooWithS(s string) StrictFoo {
	var _u StrictFoo
	_u.SetS(s)
	return _u
}

func (_m *StrictFoo) SetI(i int32) {
	_m.reset()
	_m.I_strictFooTag = StrictFooI
	_m.I = i
}

func StrictFooWithI(i int32) StrictFoo {
	var _u StrictFoo
	_u.SetI(i)
	return _u
}

type I_strictPizzaOrPastaTag uint64

const (
	StrictPizzaOrPastaPizza = 1 // 0x00000001
	StrictPizzaOrPastaPasta = 2 // 0x00000002
)

type StrictPizzaOrPasta struct {
	I_strictPizzaOrPastaTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Pizza                   Pizza `fidl_ordinal:"1"`
	Pasta                   Pasta `fidl_ordinal:"2"`
}

var _mStrictPizzaOrPasta = _bindings.CreateLazyMarshaler(StrictPizzaOrPasta{})

func (msg *StrictPizzaOrPasta) Marshaler() _bindings.Marshaler {
	return _mStrictPizzaOrPasta
}

func (_m *StrictPizzaOrPasta) reset() {
	switch _m.I_strictPizzaOrPastaTag {
	case 1:
		var _zeroed Pizza
		_m.Pizza = _zeroed
	case 2:
		var _zeroed Pasta
		_m.Pasta = _zeroed
	}
}

func (_m *StrictPizzaOrPasta) Which() I_strictPizzaOrPastaTag {
	return _m.I_strictPizzaOrPastaTag
}

func (_m *StrictPizzaOrPasta) Ordinal() uint64 {
	return uint64(_m.I_strictPizzaOrPastaTag)
}

func (_m *StrictPizzaOrPasta) SetPizza(pizza Pizza) {
	_m.reset()
	_m.I_strictPizzaOrPastaTag = StrictPizzaOrPastaPizza
	_m.Pizza = pizza
}

func StrictPizzaOrPastaWithPizza(pizza Pizza) StrictPizzaOrPasta {
	var _u StrictPizzaOrPasta
	_u.SetPizza(pizza)
	return _u
}

func (_m *StrictPizzaOrPasta) SetPasta(pasta Pasta) {
	_m.reset()
	_m.I_strictPizzaOrPastaTag = StrictPizzaOrPastaPasta
	_m.Pasta = pasta
}

func StrictPizzaOrPastaWithPasta(pasta Pasta) StrictPizzaOrPasta {
	var _u StrictPizzaOrPasta
	_u.SetPasta(pasta)
	return _u
}

type I_strictSimpleUnionTag uint64

const (
	StrictSimpleUnionI = 1 // 0x00000001
	StrictSimpleUnionF = 2 // 0x00000002
	StrictSimpleUnionS = 3 // 0x00000003
)

type StrictSimpleUnion struct {
	I_strictSimpleUnionTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I                      int32   `fidl_ordinal:"1"`
	F                      float32 `fidl_ordinal:"2"`
	S                      string  `fidl_bounds:"" fidl_ordinal:"3"`
}

var _mStrictSimpleUnion = _bindings.CreateLazyMarshaler(StrictSimpleUnion{})

func (msg *StrictSimpleUnion) Marshaler() _bindings.Marshaler {
	return _mStrictSimpleUnion
}

func (_m *StrictSimpleUnion) reset() {
	switch _m.I_strictSimpleUnionTag {
	case 1:
		var _zeroed int32
		_m.I = _zeroed
	case 2:
		var _zeroed float32
		_m.F = _zeroed
	case 3:
		var _zeroed string
		_m.S = _zeroed
	}
}

func (_m *StrictSimpleUnion) Which() I_strictSimpleUnionTag {
	return _m.I_strictSimpleUnionTag
}

func (_m *StrictSimpleUnion) Ordinal() uint64 {
	return uint64(_m.I_strictSimpleUnionTag)
}

func (_m *StrictSimpleUnion) SetI(i int32) {
	_m.reset()
	_m.I_strictSimpleUnionTag = StrictSimpleUnionI
	_m.I = i
}

func StrictSimpleUnionWithI(i int32) StrictSimpleUnion {
	var _u StrictSimpleUnion
	_u.SetI(i)
	return _u
}

func (_m *StrictSimpleUnion) SetF(f float32) {
	_m.reset()
	_m.I_strictSimpleUnionTag = StrictSimpleUnionF
	_m.F = f
}

func StrictSimpleUnionWithF(f float32) StrictSimpleUnion {
	var _u StrictSimpleUnion
	_u.SetF(f)
	return _u
}

func (_m *StrictSimpleUnion) SetS(s string) {
	_m.reset()
	_m.I_strictSimpleUnionTag = StrictSimpleUnionS
	_m.S = s
}

func StrictSimpleUnionWithS(s string) StrictSimpleUnion {
	var _u StrictSimpleUnion
	_u.SetS(s)
	return _u
}

type I_strictUnionTag uint64

const (
	StrictUnionPrimitive                        = 1 // 0x00000001
	StrictUnionStringNeedsConstructor           = 2 // 0x00000002
	StrictUnionVectorStringAlsoNeedsConstructor = 3 // 0x00000003
)

type StrictUnion struct {
	I_strictUnionTag                 `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Primitive                        int32    `fidl_ordinal:"1"`
	StringNeedsConstructor           string   `fidl_bounds:"" fidl_ordinal:"2"`
	VectorStringAlsoNeedsConstructor []string `fidl_bounds:"" fidl_ordinal:"3"`
}

var _mStrictUnion = _bindings.CreateLazyMarshaler(StrictUnion{})

func (msg *StrictUnion) Marshaler() _bindings.Marshaler {
	return _mStrictUnion
}

func (_m *StrictUnion) reset() {
	switch _m.I_strictUnionTag {
	case 1:
		var _zeroed int32
		_m.Primitive = _zeroed
	case 2:
		var _zeroed string
		_m.StringNeedsConstructor = _zeroed
	case 3:
		var _zeroed []string
		_m.VectorStringAlsoNeedsConstructor = _zeroed
	}
}

func (_m *StrictUnion) Which() I_strictUnionTag {
	return _m.I_strictUnionTag
}

func (_m *StrictUnion) Ordinal() uint64 {
	return uint64(_m.I_strictUnionTag)
}

func (_m *StrictUnion) SetPrimitive(primitive int32) {
	_m.reset()
	_m.I_strictUnionTag = StrictUnionPrimitive
	_m.Primitive = primitive
}

func StrictUnionWithPrimitive(primitive int32) StrictUnion {
	var _u StrictUnion
	_u.SetPrimitive(primitive)
	return _u
}

func (_m *StrictUnion) SetStringNeedsConstructor(stringNeedsConstructor string) {
	_m.reset()
	_m.I_strictUnionTag = StrictUnionStringNeedsConstructor
	_m.StringNeedsConstructor = stringNeedsConstructor
}

func StrictUnionWithStringNeedsConstructor(stringNeedsConstructor string) StrictUnion {
	var _u StrictUnion
	_u.SetStringNeedsConstructor(stringNeedsConstructor)
	return _u
}

func (_m *StrictUnion) SetVectorStringAlsoNeedsConstructor(vectorStringAlsoNeedsConstructor []string) {
	_m.reset()
	_m.I_strictUnionTag = StrictUnionVectorStringAlsoNeedsConstructor
	_m.VectorStringAlsoNeedsConstructor = vectorStringAlsoNeedsConstructor
}

func StrictUnionWithVectorStringAlsoNeedsConstructor(vectorStringAlsoNeedsConstructor []string) StrictUnion {
	var _u StrictUnion
	_u.SetVectorStringAlsoNeedsConstructor(vectorStringAlsoNeedsConstructor)
	return _u
}

type I_unionTag uint64

const (
	UnionPrimitive                        = 1 // 0x00000001
	UnionStringNeedsConstructor           = 2 // 0x00000002
	UnionVectorStringAlsoNeedsConstructor = 3 // 0x00000003
)

type Union struct {
	I_unionTag                       `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	Primitive                        int32    `fidl_ordinal:"1"`
	StringNeedsConstructor           string   `fidl_bounds:"" fidl_ordinal:"2"`
	VectorStringAlsoNeedsConstructor []string `fidl_bounds:"" fidl_ordinal:"3"`
}

var _mUnion = _bindings.CreateLazyMarshaler(Union{})

func (msg *Union) Marshaler() _bindings.Marshaler {
	return _mUnion
}

func (_m *Union) reset() {
	switch _m.I_unionTag {
	case 1:
		var _zeroed int32
		_m.Primitive = _zeroed
	case 2:
		var _zeroed string
		_m.StringNeedsConstructor = _zeroed
	case 3:
		var _zeroed []string
		_m.VectorStringAlsoNeedsConstructor = _zeroed
	}
}

func (_m *Union) Which() I_unionTag {
	return _m.I_unionTag
}

func (_m *Union) Ordinal() uint64 {
	return uint64(_m.I_unionTag)
}

func (_m *Union) SetPrimitive(primitive int32) {
	_m.reset()
	_m.I_unionTag = UnionPrimitive
	_m.Primitive = primitive
}

func UnionWithPrimitive(primitive int32) Union {
	var _u Union
	_u.SetPrimitive(primitive)
	return _u
}

func (_m *Union) SetStringNeedsConstructor(stringNeedsConstructor string) {
	_m.reset()
	_m.I_unionTag = UnionStringNeedsConstructor
	_m.StringNeedsConstructor = stringNeedsConstructor
}

func UnionWithStringNeedsConstructor(stringNeedsConstructor string) Union {
	var _u Union
	_u.SetStringNeedsConstructor(stringNeedsConstructor)
	return _u
}

func (_m *Union) SetVectorStringAlsoNeedsConstructor(vectorStringAlsoNeedsConstructor []string) {
	_m.reset()
	_m.I_unionTag = UnionVectorStringAlsoNeedsConstructor
	_m.VectorStringAlsoNeedsConstructor = vectorStringAlsoNeedsConstructor
}

func UnionWithVectorStringAlsoNeedsConstructor(vectorStringAlsoNeedsConstructor []string) Union {
	var _u Union
	_u.SetVectorStringAlsoNeedsConstructor(vectorStringAlsoNeedsConstructor)
	return _u
}

type I_unionContainingEmptyStructTag uint64

const (
	UnionContainingEmptyStruct_unknownData = 0 // 0x00000000
	UnionContainingEmptyStructEmpty        = 1 // 0x00000001
)

type UnionContainingEmptyStruct struct {
	I_unionContainingEmptyStructTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData                   interface{}
	Empty                           Empty `fidl_ordinal:"1"`
}

var _mUnionContainingEmptyStruct = _bindings.CreateLazyMarshaler(UnionContainingEmptyStruct{})

func (msg *UnionContainingEmptyStruct) Marshaler() _bindings.Marshaler {
	return _mUnionContainingEmptyStruct
}

func (_m *UnionContainingEmptyStruct) reset() {
	switch _m.I_unionContainingEmptyStructTag {
	case 1:
		var _zeroed Empty
		_m.Empty = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *UnionContainingEmptyStruct) Which() I_unionContainingEmptyStructTag {
	switch _m.I_unionContainingEmptyStructTag {
	case 1:
		return UnionContainingEmptyStructEmpty
	default:
		return UnionContainingEmptyStruct_unknownData
	}
}

func (_m *UnionContainingEmptyStruct) Ordinal() uint64 {
	return uint64(_m.I_unionContainingEmptyStructTag)
}

func (_m *UnionContainingEmptyStruct) SetEmpty(empty Empty) {
	_m.reset()
	_m.I_unionContainingEmptyStructTag = UnionContainingEmptyStructEmpty
	_m.Empty = empty
}

func UnionContainingEmptyStructWithEmpty(empty Empty) UnionContainingEmptyStruct {
	var _u UnionContainingEmptyStruct
	_u.SetEmpty(empty)
	return _u
}
func (_m *UnionContainingEmptyStruct) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_unionWithAttributesTag uint64

const (
	UnionWithAttributes_unknownData = 0 // 0x00000000
	UnionWithAttributesX            = 1 // 0x00000001
)

type UnionWithAttributes struct {
	I_unionWithAttributesTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
	I_unknownData            interface{}
	X                        int64 `fidl_ordinal:"1"`
}

var _mUnionWithAttributes = _bindings.CreateLazyMarshaler(UnionWithAttributes{})

func (msg *UnionWithAttributes) Marshaler() _bindings.Marshaler {
	return _mUnionWithAttributes
}

func (_m *UnionWithAttributes) reset() {
	switch _m.I_unionWithAttributesTag {
	case 1:
		var _zeroed int64
		_m.X = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *UnionWithAttributes) Which() I_unionWithAttributesTag {
	switch _m.I_unionWithAttributesTag {
	case 1:
		return UnionWithAttributesX
	default:
		return UnionWithAttributes_unknownData
	}
}

func (_m *UnionWithAttributes) Ordinal() uint64 {
	return uint64(_m.I_unionWithAttributesTag)
}

func (_m *UnionWithAttributes) SetX(x int64) {
	_m.reset()
	_m.I_unionWithAttributesTag = UnionWithAttributesX
	_m.X = x
}

func UnionWithAttributesWithX(x int64) UnionWithAttributes {
	var _u UnionWithAttributes
	_u.SetX(x)
	return _u
}
func (_m *UnionWithAttributes) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

const (
	TestProtocolStrictUnionHenceResponseMayBeStackAllocatedOrdinal   uint64 = 0x5bfca9479251b9c3
	TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedOrdinal uint64 = 0x694fede3b8829ce2
)

type TestProtocolWithCtxInterface _bindings.ChannelProxy

func (p *TestProtocolWithCtxInterface) StrictUnionHenceResponseMayBeStackAllocated(ctx_ _bindings.Context) (StrictBoundedUnion, error) {
	var req_ _bindings.Message
	resp_ := &TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(TestProtocolStrictUnionHenceResponseMayBeStackAllocatedOrdinal, req_, resp_)
	return (*resp_).Xu, err_
}

func (p *TestProtocolWithCtxInterface) FlexibleUnionHenceResponseMustBeHeapAllocated(ctx_ _bindings.Context) (OlderSimpleUnion, error) {
	var req_ _bindings.Message
	resp_ := &TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedOrdinal, req_, resp_)
	return (*resp_).Xu, err_
}

type TestProtocolWithCtx interface {
	StrictUnionHenceResponseMayBeStackAllocated(ctx_ _bindings.Context) (StrictBoundedUnion, error)
	FlexibleUnionHenceResponseMustBeHeapAllocated(ctx_ _bindings.Context) (OlderSimpleUnion, error)
}
type TestProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewTestProtocolWithCtxInterfaceRequest() (TestProtocolWithCtxInterfaceRequest, *TestProtocolWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return TestProtocolWithCtxInterfaceRequest(req), (*TestProtocolWithCtxInterface)(cli), err
}

type TestProtocolWithCtxStub struct {
	Impl TestProtocolWithCtx
}

func (s_ *TestProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case TestProtocolStrictUnionHenceResponseMayBeStackAllocatedOrdinal:
		xu, err_ := s_.Impl.StrictUnionHenceResponseMayBeStackAllocated(args_.Ctx)
		out_ := &TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse{Xu: xu}
		return out_, true, err_
	case TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedOrdinal:
		xu, err_ := s_.Impl.FlexibleUnionHenceResponseMustBeHeapAllocated(args_.Ctx)
		out_ := &TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse{Xu: xu}
		return out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type TestProtocolEventProxy _bindings.ChannelProxy