// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Code generated by third_party/go/regen-fidl; DO NOT EDIT.

package bindingstest

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

const (
	KMaxBuf uint64 = 8192
)

var _ _bindings.Enum = TestUcharEnum(0)

type TestUcharEnum uint8

const (
	TestUcharEnumUcharEnum1 TestUcharEnum = 1
	TestUcharEnumUcharEnum2 TestUcharEnum = 2
)

func (_ TestUcharEnum) I_EnumValues() []TestUcharEnum {
	return []TestUcharEnum{
		TestUcharEnumUcharEnum1,
		TestUcharEnumUcharEnum2,
	}
}

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

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

func (x TestUcharEnum) String() string {
	switch x {
	case 1:
		return "UcharEnum1"
	case 2:
		return "UcharEnum2"
	}
	return "Unknown"
}

var _ _bindings.Bits = StrictBits(0)

type StrictBits uint32

const (
	StrictBitsOne   StrictBits = 1
	StrictBitsTwo   StrictBits = 2
	StrictBits_Mask StrictBits = 3
)

func (_ StrictBits) I_BitsMask() StrictBits {
	return StrictBits_Mask
}

func (_ StrictBits) I_BitsIsStrict() bool {
	return true
}

func (x StrictBits) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x StrictBits) GetUnknownBits() uint64 {
	return uint64(^StrictBits_Mask & x)
}

func (x StrictBits) InvertBits() StrictBits {
	return StrictBits_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x StrictBits) HasBits(mask StrictBits) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x StrictBits) ClearBits(mask StrictBits) StrictBits {
	return ^mask & x
}

func (x StrictBits) String() string {
	switch x {
	case 1:
		return "One"
	case 2:
		return "Two"
	}
	return "Unknown"
}

var _ _bindings.Bits = FlexibleBits(0)

type FlexibleBits uint32

const (
	FlexibleBitsOne   FlexibleBits = 1
	FlexibleBitsTwo   FlexibleBits = 2
	FlexibleBits_Mask FlexibleBits = 3
)

func (_ FlexibleBits) I_BitsMask() FlexibleBits {
	return FlexibleBits_Mask
}

func (_ FlexibleBits) I_BitsIsStrict() bool {
	return false
}

func (x FlexibleBits) HasUnknownBits() bool {
	return x.GetUnknownBits() != 0
}

func (x FlexibleBits) GetUnknownBits() uint64 {
	return uint64(^FlexibleBits_Mask & x)
}

func (x FlexibleBits) InvertBits() FlexibleBits {
	return FlexibleBits_Mask & ^x
}

// HasBits validates that all flipped bits in the mask are set.
func (x FlexibleBits) HasBits(mask FlexibleBits) bool {
	return mask|x == x
}

// ClearBits ensures all flipped bits in the mask are unset.
func (x FlexibleBits) ClearBits(mask FlexibleBits) FlexibleBits {
	return ^mask & x
}

func (x FlexibleBits) String() string {
	switch x {
	case 1:
		return "One"
	case 2:
		return "Two"
	}
	return "Unknown"
}

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

var _mTestSimple = _bindings.CreateLazyMarshaler(TestSimple{})

func (msg *TestSimple) Marshaler() _bindings.Marshaler {
	return _mTestSimple
}

type TestSimpleBool struct {
	_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1"`
	X bool     `fidl_offset_v1:"0"`
}

var _mTestSimpleBool = _bindings.CreateLazyMarshaler(TestSimpleBool{})

func (msg *TestSimpleBool) Marshaler() _bindings.Marshaler {
	return _mTestSimpleBool
}

type TestAlignment1 struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"4"`
	X int8     `fidl_offset_v1:"0"`
	Y int8     `fidl_offset_v1:"1"`
	Z uint32   `fidl_offset_v1:"4"`
}

var _mTestAlignment1 = _bindings.CreateLazyMarshaler(TestAlignment1{})

func (msg *TestAlignment1) Marshaler() _bindings.Marshaler {
	return _mTestAlignment1
}

type TestAlignment2 struct {
	_ struct{} `fidl:"s" fidl_size_v1:"20" fidl_alignment_v1:"4"`
	A uint32   `fidl_offset_v1:"0"`
	B uint32   `fidl_offset_v1:"4"`
	C int8     `fidl_offset_v1:"8"`
	D int8     `fidl_offset_v1:"9"`
	E int8     `fidl_offset_v1:"10"`
	F uint8    `fidl_offset_v1:"11"`
	G uint32   `fidl_offset_v1:"12"`
	H uint16   `fidl_offset_v1:"16"`
	I uint16   `fidl_offset_v1:"18"`
}

var _mTestAlignment2 = _bindings.CreateLazyMarshaler(TestAlignment2{})

func (msg *TestAlignment2) Marshaler() _bindings.Marshaler {
	return _mTestAlignment2
}

type TestFloat1 struct {
	_ struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4"`
	A float32  `fidl_offset_v1:"0"`
}

var _mTestFloat1 = _bindings.CreateLazyMarshaler(TestFloat1{})

func (msg *TestFloat1) Marshaler() _bindings.Marshaler {
	return _mTestFloat1
}

type TestFloat2 struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	A float64  `fidl_offset_v1:"0"`
}

var _mTestFloat2 = _bindings.CreateLazyMarshaler(TestFloat2{})

func (msg *TestFloat2) Marshaler() _bindings.Marshaler {
	return _mTestFloat2
}

type TestFloat3 struct {
	_ struct{} `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8"`
	A float32  `fidl_offset_v1:"0"`
	B float64  `fidl_offset_v1:"8"`
	C uint64   `fidl_offset_v1:"16"`
	D float32  `fidl_offset_v1:"24"`
}

var _mTestFloat3 = _bindings.CreateLazyMarshaler(TestFloat3{})

func (msg *TestFloat3) Marshaler() _bindings.Marshaler {
	return _mTestFloat3
}

type TestArray1 struct {
	_ struct{} `fidl:"s" fidl_size_v1:"5" fidl_alignment_v1:"1"`
	A [5]int8  `fidl_offset_v1:"0"`
}

var _mTestArray1 = _bindings.CreateLazyMarshaler(TestArray1{})

func (msg *TestArray1) Marshaler() _bindings.Marshaler {
	return _mTestArray1
}

type TestArray2 struct {
	_ struct{}   `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	A float64    `fidl_offset_v1:"0"`
	B [1]float32 `fidl_offset_v1:"8"`
}

var _mTestArray2 = _bindings.CreateLazyMarshaler(TestArray2{})

func (msg *TestArray2) Marshaler() _bindings.Marshaler {
	return _mTestArray2
}

type TestArray3 struct {
	_ struct{}  `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	A int32     `fidl_offset_v1:"0"`
	B [3]uint16 `fidl_offset_v1:"4"`
	C uint64    `fidl_offset_v1:"16"`
}

var _mTestArray3 = _bindings.CreateLazyMarshaler(TestArray3{})

func (msg *TestArray3) Marshaler() _bindings.Marshaler {
	return _mTestArray3
}

type TestArray4 struct {
	_ struct{} `fidl:"s" fidl_size_v1:"9" fidl_alignment_v1:"1"`
	A [9]bool  `fidl_offset_v1:"0"`
}

var _mTestArray4 = _bindings.CreateLazyMarshaler(TestArray4{})

func (msg *TestArray4) Marshaler() _bindings.Marshaler {
	return _mTestArray4
}

type TestString1 struct {
	_ struct{} `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8"`
	A string   `fidl_offset_v1:"0" fidl_bounds:""`
	B *string  `fidl_offset_v1:"16" fidl_bounds:""`
}

var _mTestString1 = _bindings.CreateLazyMarshaler(TestString1{})

func (msg *TestString1) Marshaler() _bindings.Marshaler {
	return _mTestString1
}

type TestString2 struct {
	_ struct{}  `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8"`
	A [2]string `fidl_offset_v1:"0" fidl_bounds:""`
}

var _mTestString2 = _bindings.CreateLazyMarshaler(TestString2{})

func (msg *TestString2) Marshaler() _bindings.Marshaler {
	return _mTestString2
}

type TestString3 struct {
	_ struct{}   `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8"`
	A [2]string  `fidl_offset_v1:"0" fidl_bounds:"4"`
	B [2]*string `fidl_offset_v1:"32" fidl_bounds:"4"`
}

var _mTestString3 = _bindings.CreateLazyMarshaler(TestString3{})

func (msg *TestString3) Marshaler() _bindings.Marshaler {
	return _mTestString3
}

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

var _mTestStringWithBound = _bindings.CreateLazyMarshaler(TestStringWithBound{})

func (msg *TestStringWithBound) Marshaler() _bindings.Marshaler {
	return _mTestStringWithBound
}

type TestOptStringWithBound struct {
	_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	A *string  `fidl_offset_v1:"0" fidl_bounds:"8"`
}

var _mTestOptStringWithBound = _bindings.CreateLazyMarshaler(TestOptStringWithBound{})

func (msg *TestOptStringWithBound) Marshaler() _bindings.Marshaler {
	return _mTestOptStringWithBound
}

type TestVector1 struct {
	_ struct{} `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8"`
	A []int8   `fidl_offset_v1:"0" fidl_bounds:""`
	B *[]int16 `fidl_offset_v1:"16" fidl_bounds:""`
	C []int32  `fidl_offset_v1:"32" fidl_bounds:"2"`
	D *[]int64 `fidl_offset_v1:"48" fidl_bounds:"2"`
}

var _mTestVector1 = _bindings.CreateLazyMarshaler(TestVector1{})

func (msg *TestVector1) Marshaler() _bindings.Marshaler {
	return _mTestVector1
}

type TestVector2 struct {
	_ struct{}    `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8"`
	A [2][]int8   `fidl_offset_v1:"0" fidl_bounds:""`
	B [][]int8    `fidl_offset_v1:"32" fidl_bounds:"2,"`
	C []*[]string `fidl_offset_v1:"48" fidl_bounds:"2,2,5"`
}

var _mTestVector2 = _bindings.CreateLazyMarshaler(TestVector2{})

func (msg *TestVector2) Marshaler() _bindings.Marshaler {
	return _mTestVector2
}

type TestStruct1 struct {
	_ struct{}    `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	A TestSimple  `fidl_offset_v1:"0"`
	B *TestSimple `fidl_offset_v1:"8"`
}

var _mTestStruct1 = _bindings.CreateLazyMarshaler(TestStruct1{})

func (msg *TestStruct1) Marshaler() _bindings.Marshaler {
	return _mTestStruct1
}

type TestStruct2 struct {
	_ struct{}     `fidl:"s" fidl_size_v1:"88" fidl_alignment_v1:"8"`
	A TestArray1   `fidl_offset_v1:"0"`
	B TestFloat1   `fidl_offset_v1:"8"`
	C TestVector1  `fidl_offset_v1:"16"`
	D *TestString1 `fidl_offset_v1:"80"`
}

var _mTestStruct2 = _bindings.CreateLazyMarshaler(TestStruct2{})

func (msg *TestStruct2) Marshaler() _bindings.Marshaler {
	return _mTestStruct2
}

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

var _mEmptyStruct = _bindings.CreateLazyMarshaler(EmptyStruct{})

func (msg *EmptyStruct) Marshaler() _bindings.Marshaler {
	return _mEmptyStruct
}

type TestUnion1 struct {
	_ struct{} `fidl:"s" fidl_size_v1:"48" fidl_alignment_v1:"8"`
	A Union1   `fidl_offset_v1:"0"`
	B *Union1  `fidl_offset_v1:"24"`
}

var _mTestUnion1 = _bindings.CreateLazyMarshaler(TestUnion1{})

func (msg *TestUnion1) Marshaler() _bindings.Marshaler {
	return _mTestUnion1
}

type TestUnion2 struct {
	_ struct{}  `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8"`
	A []Union1  `fidl_offset_v1:"0" fidl_bounds:""`
	B []*Union1 `fidl_offset_v1:"16" fidl_bounds:""`
}

var _mTestUnion2 = _bindings.CreateLazyMarshaler(TestUnion2{})

func (msg *TestUnion2) Marshaler() _bindings.Marshaler {
	return _mTestUnion2
}

type XUnion1Struct struct {
	_  struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Xu XUnion1  `fidl_offset_v1:"0"`
}

var _mXUnion1Struct = _bindings.CreateLazyMarshaler(XUnion1Struct{})

func (msg *XUnion1Struct) Marshaler() _bindings.Marshaler {
	return _mXUnion1Struct
}

type XUnion1AsUnionStruct struct {
	_    struct{}       `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Xuau XUnion1AsUnion `fidl_offset_v1:"0"`
}

var _mXUnion1AsUnionStruct = _bindings.CreateLazyMarshaler(XUnion1AsUnionStruct{})

func (msg *XUnion1AsUnionStruct) Marshaler() _bindings.Marshaler {
	return _mXUnion1AsUnionStruct
}

type UnionInsideUnionStruct struct {
	_ struct{}         `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	U UnionInsideUnion `fidl_offset_v1:"0"`
}

var _mUnionInsideUnionStruct = _bindings.CreateLazyMarshaler(UnionInsideUnionStruct{})

func (msg *UnionInsideUnionStruct) Marshaler() _bindings.Marshaler {
	return _mUnionInsideUnionStruct
}

type XUnionInsideXUnionStruct struct {
	_ struct{}           `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	U XUnionInsideXUnion `fidl_offset_v1:"0"`
}

var _mXUnionInsideXUnionStruct = _bindings.CreateLazyMarshaler(XUnionInsideXUnionStruct{})

func (msg *XUnionInsideXUnionStruct) Marshaler() _bindings.Marshaler {
	return _mXUnionInsideXUnionStruct
}

type TestXUnion1 struct {
	_ struct{} `fidl:"s" fidl_size_v1:"48" fidl_alignment_v1:"8"`
	A XUnion1  `fidl_offset_v1:"0"`
	B *XUnion1 `fidl_offset_v1:"24"`
}

var _mTestXUnion1 = _bindings.CreateLazyMarshaler(TestXUnion1{})

func (msg *TestXUnion1) Marshaler() _bindings.Marshaler {
	return _mTestXUnion1
}

type TestXUnion2 struct {
	_ struct{}   `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8"`
	A []XUnion1  `fidl_offset_v1:"0" fidl_bounds:""`
	B []*XUnion1 `fidl_offset_v1:"16" fidl_bounds:""`
}

var _mTestXUnion2 = _bindings.CreateLazyMarshaler(TestXUnion2{})

func (msg *TestXUnion2) Marshaler() _bindings.Marshaler {
	return _mTestXUnion2
}

type StrictXUnion1Struct struct {
	_  struct{}      `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Xu StrictXUnion1 `fidl_offset_v1:"0"`
}

var _mStrictXUnion1Struct = _bindings.CreateLazyMarshaler(StrictXUnion1Struct{})

func (msg *StrictXUnion1Struct) Marshaler() _bindings.Marshaler {
	return _mStrictXUnion1Struct
}

type TestStrictXUnion1 struct {
	_ struct{}       `fidl:"s" fidl_size_v1:"48" fidl_alignment_v1:"8"`
	A StrictXUnion1  `fidl_offset_v1:"0"`
	B *StrictXUnion1 `fidl_offset_v1:"24"`
}

var _mTestStrictXUnion1 = _bindings.CreateLazyMarshaler(TestStrictXUnion1{})

func (msg *TestStrictXUnion1) Marshaler() _bindings.Marshaler {
	return _mTestStrictXUnion1
}

type TestStrictXUnion2 struct {
	_ struct{}         `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8"`
	A []StrictXUnion1  `fidl_offset_v1:"0" fidl_bounds:""`
	B []*StrictXUnion1 `fidl_offset_v1:"16" fidl_bounds:""`
}

var _mTestStrictXUnion2 = _bindings.CreateLazyMarshaler(TestStrictXUnion2{})

func (msg *TestStrictXUnion2) Marshaler() _bindings.Marshaler {
	return _mTestStrictXUnion2
}

type TestHandle1 struct {
	_ struct{}   `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"4"`
	A _zx.Handle `fidl_offset_v1:"0" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
	B _zx.Handle `fidl_offset_v1:"4" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
	C _zx.VMO    `fidl_offset_v1:"8" fidl_handle_subtype:"3" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
	D _zx.VMO    `fidl_offset_v1:"12" fidl_handle_subtype:"3" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
}

var _mTestHandle1 = _bindings.CreateLazyMarshaler(TestHandle1{})

func (msg *TestHandle1) Marshaler() _bindings.Marshaler {
	return _mTestHandle1
}

type TestHandle2 struct {
	_ struct{}     `fidl:"s" fidl_size_v1:"32" fidl_alignment_v1:"8"`
	A []_zx.Handle `fidl_offset_v1:"0" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"1,0"`
	B []_zx.VMO    `fidl_offset_v1:"16" fidl_handle_subtype:"3" fidl_handle_rights:"2147483648" fidl_bounds:"1,1"`
}

var _mTestHandle2 = _bindings.CreateLazyMarshaler(TestHandle2{})

func (msg *TestHandle2) Marshaler() _bindings.Marshaler {
	return _mTestHandle2
}

type HasClientEnd struct {
	_         struct{}                        `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4"`
	ClientEnd ExampleProtocolWithCtxInterface `fidl_offset_v1:"0" fidl_handle_subtype:"4"`
}

var _mHasClientEnd = _bindings.CreateLazyMarshaler(HasClientEnd{})

func (msg *HasClientEnd) Marshaler() _bindings.Marshaler {
	return _mHasClientEnd
}

type HasServerEnd struct {
	_         struct{}                               `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4"`
	ServerEnd ExampleProtocolWithCtxInterfaceRequest `fidl_offset_v1:"0" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mHasServerEnd = _bindings.CreateLazyMarshaler(HasServerEnd{})

func (msg *HasServerEnd) Marshaler() _bindings.Marshaler {
	return _mHasServerEnd
}

type TestInterface1 struct {
	_ struct{}                     `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"4"`
	A Test1WithCtxInterface        `fidl_offset_v1:"0" fidl_handle_subtype:"4"`
	B Test1WithCtxInterface        `fidl_offset_v1:"4" fidl_handle_subtype:"4"`
	C Test1WithCtxInterfaceRequest `fidl_offset_v1:"8" fidl_handle_subtype:"4" fidl_bounds:"0"`
	D Test1WithCtxInterfaceRequest `fidl_offset_v1:"12" fidl_handle_subtype:"4" fidl_bounds:"1"`
}

var _mTestInterface1 = _bindings.CreateLazyMarshaler(TestInterface1{})

func (msg *TestInterface1) Marshaler() _bindings.Marshaler {
	return _mTestInterface1
}

type TestSimpleTable struct {
	_     struct{}    `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Table SimpleTable `fidl_offset_v1:"0"`
}

var _mTestSimpleTable = _bindings.CreateLazyMarshaler(TestSimpleTable{})

func (msg *TestSimpleTable) Marshaler() _bindings.Marshaler {
	return _mTestSimpleTable
}

type TestOlderSimpleTable struct {
	_     struct{}         `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Table OlderSimpleTable `fidl_offset_v1:"0"`
}

var _mTestOlderSimpleTable = _bindings.CreateLazyMarshaler(TestOlderSimpleTable{})

func (msg *TestOlderSimpleTable) Marshaler() _bindings.Marshaler {
	return _mTestOlderSimpleTable
}

type TestNewerSimpleTable struct {
	_     struct{}         `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Table NewerSimpleTable `fidl_offset_v1:"0"`
}

var _mTestNewerSimpleTable = _bindings.CreateLazyMarshaler(TestNewerSimpleTable{})

func (msg *TestNewerSimpleTable) Marshaler() _bindings.Marshaler {
	return _mTestNewerSimpleTable
}

type TestWithTableAndInt struct {
	_     struct{}    `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Table SimpleTable `fidl_offset_v1:"0"`
	Foo   uint64      `fidl_offset_v1:"16"`
}

var _mTestWithTableAndInt = _bindings.CreateLazyMarshaler(TestWithTableAndInt{})

func (msg *TestWithTableAndInt) Marshaler() _bindings.Marshaler {
	return _mTestWithTableAndInt
}

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

var _mInt64Struct = _bindings.CreateLazyMarshaler(Int64Struct{})

func (msg *Int64Struct) Marshaler() _bindings.Marshaler {
	return _mInt64Struct
}

type TestFuchsiaIoReadAtResponse struct {
	_    struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	S    int32    `fidl_offset_v1:"0"`
	Data []uint8  `fidl_offset_v1:"8" fidl_bounds:"8192"`
}

var _mTestFuchsiaIoReadAtResponse = _bindings.CreateLazyMarshaler(TestFuchsiaIoReadAtResponse{})

func (msg *TestFuchsiaIoReadAtResponse) Marshaler() _bindings.Marshaler {
	return _mTestFuchsiaIoReadAtResponse
}

type TestFuchsiaIoWriteAtRequest struct {
	_      struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8"`
	Data   []uint8  `fidl_offset_v1:"0" fidl_bounds:"8192"`
	Offset uint64   `fidl_offset_v1:"16"`
}

var _mTestFuchsiaIoWriteAtRequest = _bindings.CreateLazyMarshaler(TestFuchsiaIoWriteAtRequest{})

func (msg *TestFuchsiaIoWriteAtRequest) Marshaler() _bindings.Marshaler {
	return _mTestFuchsiaIoWriteAtRequest
}

type TestFuchsiaPosixSocketSendMsgRequest struct {
	_        struct{}  `fidl:"s" fidl_size_v1:"56" fidl_alignment_v1:"8"`
	Sockaddr []uint8   `fidl_offset_v1:"0" fidl_bounds:"128"`
	Data     [][]uint8 `fidl_offset_v1:"16" fidl_bounds:""`
	Control  []uint8   `fidl_offset_v1:"32" fidl_bounds:""`
	Flags    int16     `fidl_offset_v1:"48"`
}

var _mTestFuchsiaPosixSocketSendMsgRequest = _bindings.CreateLazyMarshaler(TestFuchsiaPosixSocketSendMsgRequest{})

func (msg *TestFuchsiaPosixSocketSendMsgRequest) Marshaler() _bindings.Marshaler {
	return _mTestFuchsiaPosixSocketSendMsgRequest
}

type InterfaceConfig struct {
	_               struct{}        `fidl:"s" fidl_size_v1:"40" fidl_alignment_v1:"8"`
	Name            string          `fidl_offset_v1:"0" fidl_bounds:""`
	IpAddressConfig IpAddressConfig `fidl_offset_v1:"16"`
}

var _mInterfaceConfig = _bindings.CreateLazyMarshaler(InterfaceConfig{})

func (msg *InterfaceConfig) Marshaler() _bindings.Marshaler {
	return _mInterfaceConfig
}

type TestAddEthernetDeviceRequest struct {
	_               struct{}                       `fidl:"s" fidl_size_v1:"64" fidl_alignment_v1:"8"`
	TopologicalPath string                         `fidl_offset_v1:"0" fidl_bounds:""`
	Config          InterfaceConfig                `fidl_offset_v1:"16"`
	Device          EthernetDeviceWithCtxInterface `fidl_offset_v1:"56" fidl_handle_subtype:"4"`
}

var _mTestAddEthernetDeviceRequest = _bindings.CreateLazyMarshaler(TestAddEthernetDeviceRequest{})

func (msg *TestAddEthernetDeviceRequest) Marshaler() _bindings.Marshaler {
	return _mTestAddEthernetDeviceRequest
}

type TestPackageResolverResolveRequest struct {
	_            struct{}                              `fidl:"s" fidl_size_v1:"40" fidl_alignment_v1:"8"`
	PackageUrl   string                                `fidl_offset_v1:"0" fidl_bounds:""`
	Selectors    []string                              `fidl_offset_v1:"16" fidl_bounds:""`
	UpdatePolicy UpdatePolicy                          `fidl_offset_v1:"32"`
	Dir          EthernetDeviceWithCtxInterfaceRequest `fidl_offset_v1:"36" fidl_handle_subtype:"4" fidl_bounds:"0"`
}

var _mTestPackageResolverResolveRequest = _bindings.CreateLazyMarshaler(TestPackageResolverResolveRequest{})

func (msg *TestPackageResolverResolveRequest) Marshaler() _bindings.Marshaler {
	return _mTestPackageResolverResolveRequest
}

type UpdatePolicy struct {
	_                struct{} `fidl:"s" fidl_size_v1:"2" fidl_alignment_v1:"1"`
	FetchIfAbsent    bool     `fidl_offset_v1:"0"`
	AllowOldVersions bool     `fidl_offset_v1:"1"`
}

var _mUpdatePolicy = _bindings.CreateLazyMarshaler(UpdatePolicy{})

func (msg *UpdatePolicy) Marshaler() _bindings.Marshaler {
	return _mUpdatePolicy
}

type TestUcharEnumVec struct {
	_      struct{}        `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Values []TestUcharEnum `fidl_offset_v1:"0" fidl_bounds:""`
}

var _mTestUcharEnumVec = _bindings.CreateLazyMarshaler(TestUcharEnumVec{})

func (msg *TestUcharEnumVec) Marshaler() _bindings.Marshaler {
	return _mTestUcharEnumVec
}

type HandleRightsSubtypeTestStruct struct {
	_ struct{}  `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	H []_zx.VMO `fidl_offset_v1:"0" fidl_handle_subtype:"3" fidl_handle_rights:"3" fidl_bounds:",0"`
}

var _mHandleRightsSubtypeTestStruct = _bindings.CreateLazyMarshaler(HandleRightsSubtypeTestStruct{})

func (msg *HandleRightsSubtypeTestStruct) Marshaler() _bindings.Marshaler {
	return _mHandleRightsSubtypeTestStruct
}

type PlainHandleTestStruct struct {
	_ struct{}   `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4"`
	H _zx.Handle `fidl_offset_v1:"0" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}

var _mPlainHandleTestStruct = _bindings.CreateLazyMarshaler(PlainHandleTestStruct{})

func (msg *PlainHandleTestStruct) Marshaler() _bindings.Marshaler {
	return _mPlainHandleTestStruct
}

type test1WithCtxEchoRequest struct {
	_  struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	In *string  `fidl_offset_v1:"0" fidl_bounds:""`
}

var _mtest1WithCtxEchoRequest = _bindings.CreateLazyMarshaler(test1WithCtxEchoRequest{})

func (msg *test1WithCtxEchoRequest) Marshaler() _bindings.Marshaler {
	return _mtest1WithCtxEchoRequest
}

type test1WithCtxEchoResponse struct {
	_   struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8"`
	Out *string  `fidl_offset_v1:"0" fidl_bounds:""`
}

var _mtest1WithCtxEchoResponse = _bindings.CreateLazyMarshaler(test1WithCtxEchoResponse{})

func (msg *test1WithCtxEchoResponse) Marshaler() _bindings.Marshaler {
	return _mtest1WithCtxEchoResponse
}

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

var _mtest1WithCtxSurpriseResponse = _bindings.CreateLazyMarshaler(test1WithCtxSurpriseResponse{})

func (msg *test1WithCtxSurpriseResponse) Marshaler() _bindings.Marshaler {
	return _mtest1WithCtxSurpriseResponse
}

type test1WithCtxEchoHandleRightsRequest struct {
	_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	H _zx.Port `fidl_offset_v1:"0" fidl_handle_subtype:"6" fidl_handle_rights:"7" fidl_bounds:"0"`
}

var _mtest1WithCtxEchoHandleRightsRequest = _bindings.CreateLazyMarshaler(test1WithCtxEchoHandleRightsRequest{})

func (msg *test1WithCtxEchoHandleRightsRequest) Marshaler() _bindings.Marshaler {
	return _mtest1WithCtxEchoHandleRightsRequest
}

type test1WithCtxEchoHandleRightsResponse struct {
	_      struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8"`
	Rights uint32   `fidl_offset_v1:"0"`
}

var _mtest1WithCtxEchoHandleRightsResponse = _bindings.CreateLazyMarshaler(test1WithCtxEchoHandleRightsResponse{})

func (msg *test1WithCtxEchoHandleRightsResponse) Marshaler() _bindings.Marshaler {
	return _mtest1WithCtxEchoHandleRightsResponse
}

type I_union1Tag uint64

const (
	Union1A = 1 // 0x00000001
	Union1B = 2 // 0x00000002
	Union1D = 3 // 0x00000003
)

type Union1 struct {
	I_union1Tag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	A           [3]int8    `fidl_ordinal:"1"`
	B           TestSimple `fidl_ordinal:"2"`
	D           float32    `fidl_ordinal:"3"`
}

func (_m *Union1) reset() {
	switch _m.I_union1Tag {
	case 1:
		var _zeroed [3]int8
		_m.A = _zeroed
	case 2:
		var _zeroed TestSimple
		_m.B = _zeroed
	case 3:
		var _zeroed float32
		_m.D = _zeroed
	}
}

func (_m *Union1) Which() I_union1Tag {
	return _m.I_union1Tag
}

func (_m *Union1) Ordinal() uint64 {
	return uint64(_m.I_union1Tag)
}

func (_m *Union1) SetA(a [3]int8) {
	_m.reset()
	_m.I_union1Tag = Union1A
	_m.A = a
}

func Union1WithA(a [3]int8) Union1 {
	var _u Union1
	_u.SetA(a)
	return _u
}

func (_m *Union1) SetB(b TestSimple) {
	_m.reset()
	_m.I_union1Tag = Union1B
	_m.B = b
}

func Union1WithB(b TestSimple) Union1 {
	var _u Union1
	_u.SetB(b)
	return _u
}

func (_m *Union1) SetD(d float32) {
	_m.reset()
	_m.I_union1Tag = Union1D
	_m.D = d
}

func Union1WithD(d float32) Union1 {
	var _u Union1
	_u.SetD(d)
	return _u
}

type I_xUnion1Tag uint64

const (
	XUnion1_unknownData = 0 // 0x00000000
	XUnion1A            = 1 // 0x00000001
	XUnion1B            = 2 // 0x00000002
	XUnion1D            = 3 // 0x00000003
)

type XUnion1 struct {
	I_xUnion1Tag  `fidl:"x" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	I_unknownData interface{}
	A             [3]int8    `fidl_ordinal:"1"`
	B             TestSimple `fidl_ordinal:"2"`
	D             float32    `fidl_ordinal:"3"`
}

func (_m *XUnion1) reset() {
	switch _m.I_xUnion1Tag {
	case 1:
		var _zeroed [3]int8
		_m.A = _zeroed
	case 2:
		var _zeroed TestSimple
		_m.B = _zeroed
	case 3:
		var _zeroed float32
		_m.D = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *XUnion1) Which() I_xUnion1Tag {
	switch _m.I_xUnion1Tag {
	case 1:
		return XUnion1A
	case 2:
		return XUnion1B
	case 3:
		return XUnion1D
	default:
		return XUnion1_unknownData
	}
}

func (_m *XUnion1) Ordinal() uint64 {
	return uint64(_m.I_xUnion1Tag)
}

func (_m *XUnion1) SetA(a [3]int8) {
	_m.reset()
	_m.I_xUnion1Tag = XUnion1A
	_m.A = a
}

func XUnion1WithA(a [3]int8) XUnion1 {
	var _u XUnion1
	_u.SetA(a)
	return _u
}

func (_m *XUnion1) SetB(b TestSimple) {
	_m.reset()
	_m.I_xUnion1Tag = XUnion1B
	_m.B = b
}

func XUnion1WithB(b TestSimple) XUnion1 {
	var _u XUnion1
	_u.SetB(b)
	return _u
}

func (_m *XUnion1) SetD(d float32) {
	_m.reset()
	_m.I_xUnion1Tag = XUnion1D
	_m.D = d
}

func XUnion1WithD(d float32) XUnion1 {
	var _u XUnion1
	_u.SetD(d)
	return _u
}
func (_m *XUnion1) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_xUnion1AsUnionTag uint64

const (
	XUnion1AsUnionA = 1 // 0x00000001
	XUnion1AsUnionB = 2 // 0x00000002
	XUnion1AsUnionD = 3 // 0x00000003
)

type XUnion1AsUnion struct {
	I_xUnion1AsUnionTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	A                   [3]int8    `fidl_ordinal:"1"`
	B                   TestSimple `fidl_ordinal:"2"`
	D                   float32    `fidl_ordinal:"3"`
}

func (_m *XUnion1AsUnion) reset() {
	switch _m.I_xUnion1AsUnionTag {
	case 1:
		var _zeroed [3]int8
		_m.A = _zeroed
	case 2:
		var _zeroed TestSimple
		_m.B = _zeroed
	case 3:
		var _zeroed float32
		_m.D = _zeroed
	}
}

func (_m *XUnion1AsUnion) Which() I_xUnion1AsUnionTag {
	return _m.I_xUnion1AsUnionTag
}

func (_m *XUnion1AsUnion) Ordinal() uint64 {
	return uint64(_m.I_xUnion1AsUnionTag)
}

func (_m *XUnion1AsUnion) SetA(a [3]int8) {
	_m.reset()
	_m.I_xUnion1AsUnionTag = XUnion1AsUnionA
	_m.A = a
}

func XUnion1AsUnionWithA(a [3]int8) XUnion1AsUnion {
	var _u XUnion1AsUnion
	_u.SetA(a)
	return _u
}

func (_m *XUnion1AsUnion) SetB(b TestSimple) {
	_m.reset()
	_m.I_xUnion1AsUnionTag = XUnion1AsUnionB
	_m.B = b
}

func XUnion1AsUnionWithB(b TestSimple) XUnion1AsUnion {
	var _u XUnion1AsUnion
	_u.SetB(b)
	return _u
}

func (_m *XUnion1AsUnion) SetD(d float32) {
	_m.reset()
	_m.I_xUnion1AsUnionTag = XUnion1AsUnionD
	_m.D = d
}

func XUnion1AsUnionWithD(d float32) XUnion1AsUnion {
	var _u XUnion1AsUnion
	_u.SetD(d)
	return _u
}

type I_unionInsideUnionTag uint64

const (
	UnionInsideUnionA = 1 // 0x00000001
	UnionInsideUnionB = 2 // 0x00000002
)

type UnionInsideUnion struct {
	I_unionInsideUnionTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	A                     float32        `fidl_ordinal:"1"`
	B                     XUnion1AsUnion `fidl_ordinal:"2"`
}

func (_m *UnionInsideUnion) reset() {
	switch _m.I_unionInsideUnionTag {
	case 1:
		var _zeroed float32
		_m.A = _zeroed
	case 2:
		var _zeroed XUnion1AsUnion
		_m.B = _zeroed
	}
}

func (_m *UnionInsideUnion) Which() I_unionInsideUnionTag {
	return _m.I_unionInsideUnionTag
}

func (_m *UnionInsideUnion) Ordinal() uint64 {
	return uint64(_m.I_unionInsideUnionTag)
}

func (_m *UnionInsideUnion) SetA(a float32) {
	_m.reset()
	_m.I_unionInsideUnionTag = UnionInsideUnionA
	_m.A = a
}

func UnionInsideUnionWithA(a float32) UnionInsideUnion {
	var _u UnionInsideUnion
	_u.SetA(a)
	return _u
}

func (_m *UnionInsideUnion) SetB(b XUnion1AsUnion) {
	_m.reset()
	_m.I_unionInsideUnionTag = UnionInsideUnionB
	_m.B = b
}

func UnionInsideUnionWithB(b XUnion1AsUnion) UnionInsideUnion {
	var _u UnionInsideUnion
	_u.SetB(b)
	return _u
}

type I_xUnionInsideXUnionTag uint64

const (
	XUnionInsideXUnion_unknownData = 0 // 0x00000000
	XUnionInsideXUnionA            = 1 // 0x00000001
	XUnionInsideXUnionB            = 2 // 0x00000002
)

type XUnionInsideXUnion struct {
	I_xUnionInsideXUnionTag `fidl:"x" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	I_unknownData           interface{}
	A                       float32 `fidl_ordinal:"1"`
	B                       XUnion1 `fidl_ordinal:"2"`
}

func (_m *XUnionInsideXUnion) reset() {
	switch _m.I_xUnionInsideXUnionTag {
	case 1:
		var _zeroed float32
		_m.A = _zeroed
	case 2:
		var _zeroed XUnion1
		_m.B = _zeroed
	default:
		var _zeroed interface{}
		_m.I_unknownData = _zeroed
	}
}

func (_m *XUnionInsideXUnion) Which() I_xUnionInsideXUnionTag {
	switch _m.I_xUnionInsideXUnionTag {
	case 1:
		return XUnionInsideXUnionA
	case 2:
		return XUnionInsideXUnionB
	default:
		return XUnionInsideXUnion_unknownData
	}
}

func (_m *XUnionInsideXUnion) Ordinal() uint64 {
	return uint64(_m.I_xUnionInsideXUnionTag)
}

func (_m *XUnionInsideXUnion) SetA(a float32) {
	_m.reset()
	_m.I_xUnionInsideXUnionTag = XUnionInsideXUnionA
	_m.A = a
}

func XUnionInsideXUnionWithA(a float32) XUnionInsideXUnion {
	var _u XUnionInsideXUnion
	_u.SetA(a)
	return _u
}

func (_m *XUnionInsideXUnion) SetB(b XUnion1) {
	_m.reset()
	_m.I_xUnionInsideXUnionTag = XUnionInsideXUnionB
	_m.B = b
}

func XUnionInsideXUnionWithB(b XUnion1) XUnionInsideXUnion {
	var _u XUnionInsideXUnion
	_u.SetB(b)
	return _u
}
func (_m *XUnionInsideXUnion) GetUnknownData() _bindings.UnknownData {
	return _m.I_unknownData.(_bindings.UnknownData)
}

type I_strictXUnion1Tag uint64

const (
	StrictXUnion1A = 1 // 0x00000001
	StrictXUnion1B = 2 // 0x00000002
	StrictXUnion1D = 3 // 0x00000003
)

type StrictXUnion1 struct {
	I_strictXUnion1Tag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	A                  [3]int8    `fidl_ordinal:"1"`
	B                  TestSimple `fidl_ordinal:"2"`
	D                  float32    `fidl_ordinal:"3"`
}

func (_m *StrictXUnion1) reset() {
	switch _m.I_strictXUnion1Tag {
	case 1:
		var _zeroed [3]int8
		_m.A = _zeroed
	case 2:
		var _zeroed TestSimple
		_m.B = _zeroed
	case 3:
		var _zeroed float32
		_m.D = _zeroed
	}
}

func (_m *StrictXUnion1) Which() I_strictXUnion1Tag {
	return _m.I_strictXUnion1Tag
}

func (_m *StrictXUnion1) Ordinal() uint64 {
	return uint64(_m.I_strictXUnion1Tag)
}

func (_m *StrictXUnion1) SetA(a [3]int8) {
	_m.reset()
	_m.I_strictXUnion1Tag = StrictXUnion1A
	_m.A = a
}

func StrictXUnion1WithA(a [3]int8) StrictXUnion1 {
	var _u StrictXUnion1
	_u.SetA(a)
	return _u
}

func (_m *StrictXUnion1) SetB(b TestSimple) {
	_m.reset()
	_m.I_strictXUnion1Tag = StrictXUnion1B
	_m.B = b
}

func StrictXUnion1WithB(b TestSimple) StrictXUnion1 {
	var _u StrictXUnion1
	_u.SetB(b)
	return _u
}

func (_m *StrictXUnion1) SetD(d float32) {
	_m.reset()
	_m.I_strictXUnion1Tag = StrictXUnion1D
	_m.D = d
}

func StrictXUnion1WithD(d float32) StrictXUnion1 {
	var _u StrictXUnion1
	_u.SetD(d)
	return _u
}

type I_simpleUnionTag uint64

const (
	SimpleUnionI32 = 1 // 0x00000001
	SimpleUnionI64 = 2 // 0x00000002
	SimpleUnionS   = 3 // 0x00000003
	SimpleUnionStr = 4 // 0x00000004
)

type SimpleUnion struct {
	I_simpleUnionTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	I32              int32       `fidl_ordinal:"1"`
	I64              int64       `fidl_ordinal:"2"`
	S                Int64Struct `fidl_ordinal:"3"`
	Str              string      `fidl_bounds:"" fidl_ordinal:"4"`
}

func (_m *SimpleUnion) reset() {
	switch _m.I_simpleUnionTag {
	case 1:
		var _zeroed int32
		_m.I32 = _zeroed
	case 2:
		var _zeroed int64
		_m.I64 = _zeroed
	case 3:
		var _zeroed Int64Struct
		_m.S = _zeroed
	case 4:
		var _zeroed string
		_m.Str = _zeroed
	}
}

func (_m *SimpleUnion) Which() I_simpleUnionTag {
	return _m.I_simpleUnionTag
}

func (_m *SimpleUnion) Ordinal() uint64 {
	return uint64(_m.I_simpleUnionTag)
}

func (_m *SimpleUnion) SetI32(i32 int32) {
	_m.reset()
	_m.I_simpleUnionTag = SimpleUnionI32
	_m.I32 = i32
}

func SimpleUnionWithI32(i32 int32) SimpleUnion {
	var _u SimpleUnion
	_u.SetI32(i32)
	return _u
}

func (_m *SimpleUnion) SetI64(i64 int64) {
	_m.reset()
	_m.I_simpleUnionTag = SimpleUnionI64
	_m.I64 = i64
}

func SimpleUnionWithI64(i64 int64) SimpleUnion {
	var _u SimpleUnion
	_u.SetI64(i64)
	return _u
}

func (_m *SimpleUnion) SetS(s Int64Struct) {
	_m.reset()
	_m.I_simpleUnionTag = SimpleUnionS
	_m.S = s
}

func SimpleUnionWithS(s Int64Struct) SimpleUnion {
	var _u SimpleUnion
	_u.SetS(s)
	return _u
}

func (_m *SimpleUnion) SetStr(str string) {
	_m.reset()
	_m.I_simpleUnionTag = SimpleUnionStr
	_m.Str = str
}

func SimpleUnionWithStr(str string) SimpleUnion {
	var _u SimpleUnion
	_u.SetStr(str)
	return _u
}

type I_ipAddressConfigTag uint64

const (
	IpAddressConfigPaddingSize24Align4 = 1 // 0x00000001
	IpAddressConfigDhcp                = 2 // 0x00000002
)

type IpAddressConfig struct {
	I_ipAddressConfigTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"`
	PaddingSize24Align4  [6]uint32 `fidl_ordinal:"1"`
	Dhcp                 bool      `fidl_ordinal:"2"`
}

func (_m *IpAddressConfig) reset() {
	switch _m.I_ipAddressConfigTag {
	case 1:
		var _zeroed [6]uint32
		_m.PaddingSize24Align4 = _zeroed
	case 2:
		var _zeroed bool
		_m.Dhcp = _zeroed
	}
}

func (_m *IpAddressConfig) Which() I_ipAddressConfigTag {
	return _m.I_ipAddressConfigTag
}

func (_m *IpAddressConfig) Ordinal() uint64 {
	return uint64(_m.I_ipAddressConfigTag)
}

func (_m *IpAddressConfig) SetPaddingSize24Align4(paddingSize24Align4 [6]uint32) {
	_m.reset()
	_m.I_ipAddressConfigTag = IpAddressConfigPaddingSize24Align4
	_m.PaddingSize24Align4 = paddingSize24Align4
}

func IpAddressConfigWithPaddingSize24Align4(paddingSize24Align4 [6]uint32) IpAddressConfig {
	var _u IpAddressConfig
	_u.SetPaddingSize24Align4(paddingSize24Align4)
	return _u
}

func (_m *IpAddressConfig) SetDhcp(dhcp bool) {
	_m.reset()
	_m.I_ipAddressConfigTag = IpAddressConfigDhcp
	_m.Dhcp = dhcp
}

func IpAddressConfigWithDhcp(dhcp bool) IpAddressConfig {
	var _u IpAddressConfig
	_u.SetDhcp(dhcp)
	return _u
}

type SimpleTable struct {
	_             struct{} `fidl:"t" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_resource:"false"`
	I_unknownData interface{}
	X             int64 `fidl_ordinal:"1"`
	XPresent      bool
	Y             int64 `fidl_ordinal:"5"`
	YPresent      bool
}

func (u *SimpleTable) SetX(x int64) {
	u.X = x
	u.XPresent = true
}

func (u *SimpleTable) GetX() int64 {
	return u.X
}

func (u *SimpleTable) GetXWithDefault(_default int64) int64 {
	if !u.HasX() {
		return _default
	}
	return u.X
}

func (u *SimpleTable) HasX() bool {
	return u.XPresent
}

func (u *SimpleTable) ClearX() {
	u.XPresent = false
}

func (u *SimpleTable) SetY(y int64) {
	u.Y = y
	u.YPresent = true
}

func (u *SimpleTable) GetY() int64 {
	return u.Y
}

func (u *SimpleTable) GetYWithDefault(_default int64) int64 {
	if !u.HasY() {
		return _default
	}
	return u.Y
}

func (u *SimpleTable) HasY() bool {
	return u.YPresent
}

func (u *SimpleTable) ClearY() {
	u.YPresent = false
}

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

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

type OlderSimpleTable struct {
	_             struct{} `fidl:"t" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_resource:"false"`
	I_unknownData interface{}
	X             int64 `fidl_ordinal:"1"`
	XPresent      bool
}

func (u *OlderSimpleTable) SetX(x int64) {
	u.X = x
	u.XPresent = true
}

func (u *OlderSimpleTable) GetX() int64 {
	return u.X
}

func (u *OlderSimpleTable) GetXWithDefault(_default int64) int64 {
	if !u.HasX() {
		return _default
	}
	return u.X
}

func (u *OlderSimpleTable) HasX() bool {
	return u.XPresent
}

func (u *OlderSimpleTable) ClearX() {
	u.XPresent = false
}

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

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

type NewerSimpleTable struct {
	_             struct{} `fidl:"t" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_resource:"false"`
	I_unknownData interface{}
	X             int64 `fidl_ordinal:"1"`
	XPresent      bool
	Y             int64 `fidl_ordinal:"5"`
	YPresent      bool
	Z             int64 `fidl_ordinal:"6"`
	ZPresent      bool
}

func (u *NewerSimpleTable) SetX(x int64) {
	u.X = x
	u.XPresent = true
}

func (u *NewerSimpleTable) GetX() int64 {
	return u.X
}

func (u *NewerSimpleTable) GetXWithDefault(_default int64) int64 {
	if !u.HasX() {
		return _default
	}
	return u.X
}

func (u *NewerSimpleTable) HasX() bool {
	return u.XPresent
}

func (u *NewerSimpleTable) ClearX() {
	u.XPresent = false
}

func (u *NewerSimpleTable) SetY(y int64) {
	u.Y = y
	u.YPresent = true
}

func (u *NewerSimpleTable) GetY() int64 {
	return u.Y
}

func (u *NewerSimpleTable) GetYWithDefault(_default int64) int64 {
	if !u.HasY() {
		return _default
	}
	return u.Y
}

func (u *NewerSimpleTable) HasY() bool {
	return u.YPresent
}

func (u *NewerSimpleTable) ClearY() {
	u.YPresent = false
}

func (u *NewerSimpleTable) SetZ(z int64) {
	u.Z = z
	u.ZPresent = true
}

func (u *NewerSimpleTable) GetZ() int64 {
	return u.Z
}

func (u *NewerSimpleTable) GetZWithDefault(_default int64) int64 {
	if !u.HasZ() {
		return _default
	}
	return u.Z
}

func (u *NewerSimpleTable) HasZ() bool {
	return u.ZPresent
}

func (u *NewerSimpleTable) ClearZ() {
	u.ZPresent = false
}

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

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

const (
	Test1EchoOrdinal             uint64 = 0x4adc92c9e871ae62
	Test1NoResponseOrdinal       uint64 = 0x584f4d438578f337
	Test1EmptyResponseOrdinal    uint64 = 0x12ee80a1f8a85427
	Test1SurpriseOrdinal         uint64 = 0xf93fd4731796fd9
	Test1EchoHandleRightsOrdinal uint64 = 0x53b1df24e93e434e
)

type Test1WithCtxInterface _bindings.ChannelProxy

func (p *Test1WithCtxInterface) Echo(ctx_ _bindings.Context, in *string) (*string, error) {
	req_ := &test1WithCtxEchoRequest{
		In: in,
	}
	resp_ := &test1WithCtxEchoResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Test1EchoOrdinal, req_, resp_)
	return resp_.Out, err_
}

func (p *Test1WithCtxInterface) NoResponse(ctx_ _bindings.Context) error {
	var req_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Send(Test1NoResponseOrdinal, req_)
	return err_
}

func (p *Test1WithCtxInterface) EmptyResponse(ctx_ _bindings.Context) error {
	var req_ _bindings.Message
	var resp_ _bindings.Message
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Test1EmptyResponseOrdinal, req_, resp_)
	return err_
}

func (p *Test1WithCtxInterface) ExpectSurprise(ctx_ _bindings.Context) (string, error) {
	resp_ := &test1WithCtxSurpriseResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Recv(Test1SurpriseOrdinal, resp_)
	return resp_.Foo, err_
}

func (p *Test1WithCtxInterface) EchoHandleRights(ctx_ _bindings.Context, h _zx.Port) (uint32, error) {
	req_ := &test1WithCtxEchoHandleRightsRequest{
		H: h,
	}
	resp_ := &test1WithCtxEchoHandleRightsResponse{}
	err_ := ((*_bindings.ChannelProxy)(p)).Call(Test1EchoHandleRightsOrdinal, req_, resp_)
	return resp_.Rights, err_
}

type Test1WithCtx interface {
	Echo(ctx_ _bindings.Context, in *string) (*string, error)
	NoResponse(ctx_ _bindings.Context) error
	EmptyResponse(ctx_ _bindings.Context) error
	EchoHandleRights(ctx_ _bindings.Context, h _zx.Port) (uint32, error)
}

type Test1WithCtxTransitionalBase struct{}

type Test1WithCtxInterfaceRequest _bindings.InterfaceRequest

func NewTest1WithCtxInterfaceRequest() (Test1WithCtxInterfaceRequest, *Test1WithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return Test1WithCtxInterfaceRequest(req), (*Test1WithCtxInterface)(cli), err
}

type Test1WithCtxStub struct {
	Impl Test1WithCtx
}

func (s_ *Test1WithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
	switch args_.Ordinal {
	case Test1EchoOrdinal:
		in_ := test1WithCtxEchoRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		out, err_ := s_.Impl.Echo(args_.Ctx, in_.In)
		out_ := test1WithCtxEchoResponse{}
		out_.Out = out
		return &out_, true, err_
	case Test1NoResponseOrdinal:
		err_ := s_.Impl.NoResponse(args_.Ctx)
		return nil, false, err_
	case Test1EmptyResponseOrdinal:
		err_ := s_.Impl.EmptyResponse(args_.Ctx)
		return nil, true, err_
	case Test1EchoHandleRightsOrdinal:
		in_ := test1WithCtxEchoHandleRightsRequest{}
		marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
		if !ok {
			return nil, false, _bindings.ErrMissingMarshalerContext
		}
		if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
			return nil, false, err_
		}
		rights, err_ := s_.Impl.EchoHandleRights(args_.Ctx, in_.H)
		out_ := test1WithCtxEchoHandleRightsResponse{}
		out_.Rights = rights
		return &out_, true, err_
	}
	return nil, false, _bindings.ErrUnknownOrdinal
}

type Test1EventProxy _bindings.ChannelProxy

func (p *Test1EventProxy) Surprise(foo string) error {
	event_ := &test1WithCtxSurpriseResponse{
		Foo: foo,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(Test1SurpriseOrdinal, event_)
}

type ExampleProtocolWithCtxInterface _bindings.ChannelProxy

type ExampleProtocolWithCtx interface {
}

type ExampleProtocolWithCtxTransitionalBase struct{}

type ExampleProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewExampleProtocolWithCtxInterfaceRequest() (ExampleProtocolWithCtxInterfaceRequest, *ExampleProtocolWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return ExampleProtocolWithCtxInterfaceRequest(req), (*ExampleProtocolWithCtxInterface)(cli), err
}

type ExampleProtocolWithCtxStub struct {
	Impl ExampleProtocolWithCtx
}

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

type ExampleProtocolEventProxy _bindings.ChannelProxy

type EthernetDeviceWithCtxInterface _bindings.ChannelProxy

type EthernetDeviceWithCtx interface {
}

type EthernetDeviceWithCtxTransitionalBase struct{}

type EthernetDeviceWithCtxInterfaceRequest _bindings.InterfaceRequest

func NewEthernetDeviceWithCtxInterfaceRequest() (EthernetDeviceWithCtxInterfaceRequest, *EthernetDeviceWithCtxInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return EthernetDeviceWithCtxInterfaceRequest(req), (*EthernetDeviceWithCtxInterface)(cli), err
}

type EthernetDeviceWithCtxStub struct {
	Impl EthernetDeviceWithCtx
}

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

type EthernetDeviceEventProxy _bindings.ChannelProxy