vom/testdata/types/types.vdl.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file was auto-generated by the vanadium vdl tool.
// Package: types

package types

import (
	"fmt"
	"reflect"
	"v.io/v23/vdl"
	"v.io/v23/vdl/vdlconv"
)

var _ = __VDLInit() // Must be first; see __VDLInit comments for details.

//////////////////////////////////////////////////
// Type definitions

// TestCase represents an individual testcase for vom encoding and decoding.
type TestCase struct {
	Name       string     // Name of the testcase
	Value      *vdl.Value // Value to test
	TypeString string     // The string representation of the Type
	Hex        string     // Hex pattern representing vom encoding
	HexVersion string     // Hex pattern representing vom encoding of Version
	HexType    string     // Hex pattern representing vom encoding of Type
	HexValue   string     // Hex pattern representing vom encoding of Value
}

func (TestCase) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.TestCase"`
}) {
}

func (m *TestCase) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Value")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.Value == nil {
			if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		} else {
			if err := vdl.FromValue(fieldTarget5, m.Value); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("TypeString")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget7.FromString(string(m.TypeString), tt.NonOptional().Field(2).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Hex")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget9.FromString(string(m.Hex), tt.NonOptional().Field(3).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
			return err
		}
	}
	keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("HexVersion")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget11.FromString(string(m.HexVersion), tt.NonOptional().Field(4).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
			return err
		}
	}
	keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("HexType")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget13.FromString(string(m.HexType), tt.NonOptional().Field(5).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
			return err
		}
	}
	keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("HexValue")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget15.FromString(string(m.HexValue), tt.NonOptional().Field(6).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *TestCase) MakeVDLTarget() vdl.Target {
	return &TestCaseTarget{Value: m}
}

type TestCaseTarget struct {
	Value      *TestCase
	nameTarget vdl.StringTarget

	typeStringTarget vdl.StringTarget
	hexTarget        vdl.StringTarget
	hexVersionTarget vdl.StringTarget
	hexTypeTarget    vdl.StringTarget
	hexValueTarget   vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *TestCaseTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*TestCase)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *TestCaseTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		t.nameTarget.Value = &t.Value.Name
		target, err := &t.nameTarget, error(nil)
		return nil, target, err
	case "Value":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Value))
		return nil, target, err
	case "TypeString":
		t.typeStringTarget.Value = &t.Value.TypeString
		target, err := &t.typeStringTarget, error(nil)
		return nil, target, err
	case "Hex":
		t.hexTarget.Value = &t.Value.Hex
		target, err := &t.hexTarget, error(nil)
		return nil, target, err
	case "HexVersion":
		t.hexVersionTarget.Value = &t.Value.HexVersion
		target, err := &t.hexVersionTarget, error(nil)
		return nil, target, err
	case "HexType":
		t.hexTypeTarget.Value = &t.Value.HexType
		target, err := &t.hexTypeTarget, error(nil)
		return nil, target, err
	case "HexValue":
		t.hexValueTarget.Value = &t.Value.HexValue
		target, err := &t.hexValueTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.TestCase", name)
	}
}
func (t *TestCaseTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *TestCaseTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// vomdata config types
type ConvertGroup struct {
	Name        string
	PrimaryType *vdl.Type
	Values      []*vdl.Value
}

func (ConvertGroup) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.ConvertGroup"`
}) {
}

func (m *ConvertGroup) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("PrimaryType")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		typeObjectVal6 := m.PrimaryType
		if typeObjectVal6 == nil {
			typeObjectVal6 = vdl.AnyType
		}
		if err := fieldTarget5.FromTypeObject(typeObjectVal6); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Values")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		listTarget9, err := fieldTarget8.StartList(tt.NonOptional().Field(2).Type, len(m.Values))
		if err != nil {
			return err
		}
		for i, elem11 := range m.Values {
			elemTarget10, err := listTarget9.StartElem(i)
			if err != nil {
				return err
			}

			if elem11 == nil {
				if err := elemTarget10.FromNil(tt.NonOptional().Field(2).Type.Elem()); err != nil {
					return err
				}
			} else {
				if err := vdl.FromValue(elemTarget10, elem11); err != nil {
					return err
				}
			}
			if err := listTarget9.FinishElem(elemTarget10); err != nil {
				return err
			}
		}
		if err := fieldTarget8.FinishList(listTarget9); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *ConvertGroup) MakeVDLTarget() vdl.Target {
	return &ConvertGroupTarget{Value: m}
}

type ConvertGroupTarget struct {
	Value             *ConvertGroup
	nameTarget        vdl.StringTarget
	primaryTypeTarget vdl.TypeObjectTarget
	valuesTarget      __VDLTarget1_list
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ConvertGroupTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*ConvertGroup)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *ConvertGroupTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		t.nameTarget.Value = &t.Value.Name
		target, err := &t.nameTarget, error(nil)
		return nil, target, err
	case "PrimaryType":
		t.primaryTypeTarget.Value = &t.Value.PrimaryType
		target, err := &t.primaryTypeTarget, error(nil)
		return nil, target, err
	case "Values":
		t.valuesTarget.Value = &t.Value.Values
		target, err := &t.valuesTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.ConvertGroup", name)
	}
}
func (t *ConvertGroupTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ConvertGroupTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// []*vdl.Value
type __VDLTarget1_list struct {
	Value *[]*vdl.Value

	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget1_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]*vdl.Value)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]*vdl.Value, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget1_list) StartElem(index int) (elem vdl.Target, _ error) {
	target, err := vdl.ReflectTarget(reflect.ValueOf(&(*t.Value)[index]))
	return target, err
}
func (t *__VDLTarget1_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget1_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

type VomdataStruct struct {
	EncodeDecodeData map[byte][]*vdl.Value // map from min required VOM version to test values
	CompatData       map[string][]*vdl.Type
	ConvertData      map[string][]ConvertGroup
}

func (VomdataStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.VomdataStruct"`
}) {
}

func (m *VomdataStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("EncodeDecodeData")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.EncodeDecodeData))
		if err != nil {
			return err
		}
		for key6, value8 := range m.EncodeDecodeData {
			keyTarget5, err := mapTarget4.StartKey()
			if err != nil {
				return err
			}
			if err := keyTarget5.FromUint(uint64(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
				return err
			}
			valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5)
			if err != nil {
				return err
			}

			listTarget9, err := valueTarget7.StartList(tt.NonOptional().Field(0).Type.Elem(), len(value8))
			if err != nil {
				return err
			}
			for i, elem11 := range value8 {
				elemTarget10, err := listTarget9.StartElem(i)
				if err != nil {
					return err
				}

				if elem11 == nil {
					if err := elemTarget10.FromNil(tt.NonOptional().Field(0).Type.Elem().Elem()); err != nil {
						return err
					}
				} else {
					if err := vdl.FromValue(elemTarget10, elem11); err != nil {
						return err
					}
				}
				if err := listTarget9.FinishElem(elemTarget10); err != nil {
					return err
				}
			}
			if err := valueTarget7.FinishList(listTarget9); err != nil {
				return err
			}
			if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil {
				return err
			}
		}
		if err := fieldTarget3.FinishMap(mapTarget4); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("CompatData")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		mapTarget14, err := fieldTarget13.StartMap(tt.NonOptional().Field(1).Type, len(m.CompatData))
		if err != nil {
			return err
		}
		for key16, value18 := range m.CompatData {
			keyTarget15, err := mapTarget14.StartKey()
			if err != nil {
				return err
			}
			if err := keyTarget15.FromString(string(key16), tt.NonOptional().Field(1).Type.Key()); err != nil {
				return err
			}
			valueTarget17, err := mapTarget14.FinishKeyStartField(keyTarget15)
			if err != nil {
				return err
			}

			listTarget19, err := valueTarget17.StartList(tt.NonOptional().Field(1).Type.Elem(), len(value18))
			if err != nil {
				return err
			}
			for i, elem21 := range value18 {
				elemTarget20, err := listTarget19.StartElem(i)
				if err != nil {
					return err
				}
				typeObjectVal22 := elem21
				if typeObjectVal22 == nil {
					typeObjectVal22 = vdl.AnyType
				}
				if err := elemTarget20.FromTypeObject(typeObjectVal22); err != nil {
					return err
				}
				if err := listTarget19.FinishElem(elemTarget20); err != nil {
					return err
				}
			}
			if err := valueTarget17.FinishList(listTarget19); err != nil {
				return err
			}
			if err := mapTarget14.FinishField(keyTarget15, valueTarget17); err != nil {
				return err
			}
		}
		if err := fieldTarget13.FinishMap(mapTarget14); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
			return err
		}
	}
	keyTarget23, fieldTarget24, err := fieldsTarget1.StartField("ConvertData")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		mapTarget25, err := fieldTarget24.StartMap(tt.NonOptional().Field(2).Type, len(m.ConvertData))
		if err != nil {
			return err
		}
		for key27, value29 := range m.ConvertData {
			keyTarget26, err := mapTarget25.StartKey()
			if err != nil {
				return err
			}
			if err := keyTarget26.FromString(string(key27), tt.NonOptional().Field(2).Type.Key()); err != nil {
				return err
			}
			valueTarget28, err := mapTarget25.FinishKeyStartField(keyTarget26)
			if err != nil {
				return err
			}

			listTarget30, err := valueTarget28.StartList(tt.NonOptional().Field(2).Type.Elem(), len(value29))
			if err != nil {
				return err
			}
			for i, elem32 := range value29 {
				elemTarget31, err := listTarget30.StartElem(i)
				if err != nil {
					return err
				}

				if err := elem32.FillVDLTarget(elemTarget31, tt.NonOptional().Field(2).Type.Elem().Elem()); err != nil {
					return err
				}
				if err := listTarget30.FinishElem(elemTarget31); err != nil {
					return err
				}
			}
			if err := valueTarget28.FinishList(listTarget30); err != nil {
				return err
			}
			if err := mapTarget25.FinishField(keyTarget26, valueTarget28); err != nil {
				return err
			}
		}
		if err := fieldTarget24.FinishMap(mapTarget25); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget23, fieldTarget24); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *VomdataStruct) MakeVDLTarget() vdl.Target {
	return &VomdataStructTarget{Value: m}
}

type VomdataStructTarget struct {
	Value                  *VomdataStruct
	encodeDecodeDataTarget __VDLTarget2_map
	compatDataTarget       __VDLTarget3_map
	convertDataTarget      __VDLTarget4_map
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *VomdataStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*VomdataStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *VomdataStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "EncodeDecodeData":
		t.encodeDecodeDataTarget.Value = &t.Value.EncodeDecodeData
		target, err := &t.encodeDecodeDataTarget, error(nil)
		return nil, target, err
	case "CompatData":
		t.compatDataTarget.Value = &t.Value.CompatData
		target, err := &t.compatDataTarget, error(nil)
		return nil, target, err
	case "ConvertData":
		t.convertDataTarget.Value = &t.Value.ConvertData
		target, err := &t.convertDataTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.VomdataStruct", name)
	}
}
func (t *VomdataStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *VomdataStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// map[byte][]*vdl.Value
type __VDLTarget2_map struct {
	Value      *map[byte][]*vdl.Value
	currKey    byte
	currElem   []*vdl.Value
	keyTarget  vdl.ByteTarget
	elemTarget __VDLTarget1_list
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget2_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[byte][]*vdl.Value)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[byte][]*vdl.Value)
	return t, nil
}
func (t *__VDLTarget2_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = byte(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget2_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = []*vdl.Value(nil)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget2_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget2_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// map[string][]*vdl.Type
type __VDLTarget3_map struct {
	Value      *map[string][]*vdl.Type
	currKey    string
	currElem   []*vdl.Type
	keyTarget  vdl.StringTarget
	elemTarget __VDLTarget5_list
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget3_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[string][]*vdl.Type)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[string][]*vdl.Type)
	return t, nil
}
func (t *__VDLTarget3_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = ""
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget3_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = []*vdl.Type(nil)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget3_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget3_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// []*vdl.Type
type __VDLTarget5_list struct {
	Value      *[]*vdl.Type
	elemTarget vdl.TypeObjectTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget5_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]*vdl.Type)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]*vdl.Type, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget5_list) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget5_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget5_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

// map[string][]ConvertGroup
type __VDLTarget4_map struct {
	Value      *map[string][]ConvertGroup
	currKey    string
	currElem   []ConvertGroup
	keyTarget  vdl.StringTarget
	elemTarget __VDLTarget6_list
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget4_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[string][]ConvertGroup)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[string][]ConvertGroup)
	return t, nil
}
func (t *__VDLTarget4_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = ""
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget4_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = []ConvertGroup(nil)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget4_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget4_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// []ConvertGroup
type __VDLTarget6_list struct {
	Value      *[]ConvertGroup
	elemTarget ConvertGroupTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget6_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]ConvertGroup)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]ConvertGroup, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget6_list) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget6_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget6_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

// Named Types
type NBool bool

func (NBool) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NBool"`
}) {
}

func (m *NBool) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromBool(bool((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NBool) MakeVDLTarget() vdl.Target {
	return &NBoolTarget{Value: m}
}

type NBoolTarget struct {
	Value *NBool
	vdl.TargetBase
}

func (t *NBoolTarget) FromBool(src bool, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*NBool)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = NBool(src)

	return nil
}

type NString string

func (NString) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NString"`
}) {
}

func (m *NString) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromString(string((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NString) MakeVDLTarget() vdl.Target {
	return &NStringTarget{Value: m}
}

type NStringTarget struct {
	Value *NString
	vdl.TargetBase
}

func (t *NStringTarget) FromString(src string, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*NString)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = NString(src)

	return nil
}

type NByteSlice []byte

func (NByteSlice) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NByteSlice"`
}) {
}

func (m *NByteSlice) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromBytes([]byte((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NByteSlice) MakeVDLTarget() vdl.Target {
	return &NByteSliceTarget{Value: m}
}

type NByteSliceTarget struct {
	Value *NByteSlice
	vdl.TargetBase
}

func (t *NByteSliceTarget) FromBytes(src []byte, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*NByteSlice)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if len(src) == 0 {
		*t.Value = nil
	} else {
		*t.Value = make([]byte, len(src))
		copy(*t.Value, src)
	}

	return nil
}

type NByteArray [4]byte

func (NByteArray) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NByteArray"`
}) {
}

func (m *NByteArray) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromBytes([]byte((*m)[:]), tt); err != nil {
		return err
	}
	return nil
}

func (m *NByteArray) MakeVDLTarget() vdl.Target {
	return &NByteArrayTarget{Value: m}
}

type NByteArrayTarget struct {
	Value *NByteArray
	vdl.TargetBase
}

func (t *NByteArrayTarget) FromBytes(src []byte, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*NByteArray)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	copy((*t.Value)[:], src)

	return nil
}

type NByte byte

func (NByte) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NByte"`
}) {
}

func (m *NByte) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromUint(uint64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NByte) MakeVDLTarget() vdl.Target {
	return &NByteTarget{Value: m}
}

type NByteTarget struct {
	Value *NByte
	vdl.TargetBase
}

func (t *NByteTarget) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToUint8(src)
	if err != nil {
		return err
	}
	*t.Value = NByte(val)

	return nil
}
func (t *NByteTarget) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToUint8(src)
	if err != nil {
		return err
	}
	*t.Value = NByte(val)

	return nil
}
func (t *NByteTarget) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToUint8(src)
	if err != nil {
		return err
	}
	*t.Value = NByte(val)

	return nil
}

type NUint16 uint16

func (NUint16) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NUint16"`
}) {
}

func (m *NUint16) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromUint(uint64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NUint16) MakeVDLTarget() vdl.Target {
	return &NUint16Target{Value: m}
}

type NUint16Target struct {
	Value *NUint16
	vdl.TargetBase
}

func (t *NUint16Target) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToUint16(src)
	if err != nil {
		return err
	}
	*t.Value = NUint16(val)

	return nil
}
func (t *NUint16Target) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToUint16(src)
	if err != nil {
		return err
	}
	*t.Value = NUint16(val)

	return nil
}
func (t *NUint16Target) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToUint16(src)
	if err != nil {
		return err
	}
	*t.Value = NUint16(val)

	return nil
}

type NUint32 uint32

func (NUint32) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NUint32"`
}) {
}

func (m *NUint32) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromUint(uint64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NUint32) MakeVDLTarget() vdl.Target {
	return &NUint32Target{Value: m}
}

type NUint32Target struct {
	Value *NUint32
	vdl.TargetBase
}

func (t *NUint32Target) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToUint32(src)
	if err != nil {
		return err
	}
	*t.Value = NUint32(val)

	return nil
}
func (t *NUint32Target) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToUint32(src)
	if err != nil {
		return err
	}
	*t.Value = NUint32(val)

	return nil
}
func (t *NUint32Target) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToUint32(src)
	if err != nil {
		return err
	}
	*t.Value = NUint32(val)

	return nil
}

type NUint64 uint64

func (NUint64) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NUint64"`
}) {
}

func (m *NUint64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromUint(uint64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NUint64) MakeVDLTarget() vdl.Target {
	return &NUint64Target{Value: m}
}

type NUint64Target struct {
	Value *NUint64
	vdl.TargetBase
}

func (t *NUint64Target) FromUint(src uint64, tt *vdl.Type) error {

	*t.Value = NUint64(src)

	return nil
}
func (t *NUint64Target) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToUint64(src)
	if err != nil {
		return err
	}
	*t.Value = NUint64(val)

	return nil
}
func (t *NUint64Target) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToUint64(src)
	if err != nil {
		return err
	}
	*t.Value = NUint64(val)

	return nil
}

type NInt8 int8

func (NInt8) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NInt8"`
}) {
}

func (m *NInt8) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromInt(int64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NInt8) MakeVDLTarget() vdl.Target {
	return &NInt8Target{Value: m}
}

type NInt8Target struct {
	Value *NInt8
	vdl.TargetBase
}

func (t *NInt8Target) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToInt8(src)
	if err != nil {
		return err
	}
	*t.Value = NInt8(val)

	return nil
}
func (t *NInt8Target) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToInt8(src)
	if err != nil {
		return err
	}
	*t.Value = NInt8(val)

	return nil
}
func (t *NInt8Target) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToInt8(src)
	if err != nil {
		return err
	}
	*t.Value = NInt8(val)

	return nil
}

type NInt16 int16

func (NInt16) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NInt16"`
}) {
}

func (m *NInt16) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromInt(int64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NInt16) MakeVDLTarget() vdl.Target {
	return &NInt16Target{Value: m}
}

type NInt16Target struct {
	Value *NInt16
	vdl.TargetBase
}

func (t *NInt16Target) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToInt16(src)
	if err != nil {
		return err
	}
	*t.Value = NInt16(val)

	return nil
}
func (t *NInt16Target) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToInt16(src)
	if err != nil {
		return err
	}
	*t.Value = NInt16(val)

	return nil
}
func (t *NInt16Target) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToInt16(src)
	if err != nil {
		return err
	}
	*t.Value = NInt16(val)

	return nil
}

type NInt32 int32

func (NInt32) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NInt32"`
}) {
}

func (m *NInt32) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromInt(int64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NInt32) MakeVDLTarget() vdl.Target {
	return &NInt32Target{Value: m}
}

type NInt32Target struct {
	Value *NInt32
	vdl.TargetBase
}

func (t *NInt32Target) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToInt32(src)
	if err != nil {
		return err
	}
	*t.Value = NInt32(val)

	return nil
}
func (t *NInt32Target) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToInt32(src)
	if err != nil {
		return err
	}
	*t.Value = NInt32(val)

	return nil
}
func (t *NInt32Target) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToInt32(src)
	if err != nil {
		return err
	}
	*t.Value = NInt32(val)

	return nil
}

type NInt64 int64

func (NInt64) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NInt64"`
}) {
}

func (m *NInt64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromInt(int64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NInt64) MakeVDLTarget() vdl.Target {
	return &NInt64Target{Value: m}
}

type NInt64Target struct {
	Value *NInt64
	vdl.TargetBase
}

func (t *NInt64Target) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToInt64(src)
	if err != nil {
		return err
	}
	*t.Value = NInt64(val)

	return nil
}
func (t *NInt64Target) FromInt(src int64, tt *vdl.Type) error {

	*t.Value = NInt64(src)

	return nil
}
func (t *NInt64Target) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToInt64(src)
	if err != nil {
		return err
	}
	*t.Value = NInt64(val)

	return nil
}

type NFloat32 float32

func (NFloat32) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NFloat32"`
}) {
}

func (m *NFloat32) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromFloat(float64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NFloat32) MakeVDLTarget() vdl.Target {
	return &NFloat32Target{Value: m}
}

type NFloat32Target struct {
	Value *NFloat32
	vdl.TargetBase
}

func (t *NFloat32Target) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToFloat32(src)
	if err != nil {
		return err
	}
	*t.Value = NFloat32(val)

	return nil
}
func (t *NFloat32Target) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToFloat32(src)
	if err != nil {
		return err
	}
	*t.Value = NFloat32(val)

	return nil
}
func (t *NFloat32Target) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToFloat32(src)
	if err != nil {
		return err
	}
	*t.Value = NFloat32(val)

	return nil
}

type NFloat64 float64

func (NFloat64) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NFloat64"`
}) {
}

func (m *NFloat64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromFloat(float64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *NFloat64) MakeVDLTarget() vdl.Target {
	return &NFloat64Target{Value: m}
}

type NFloat64Target struct {
	Value *NFloat64
	vdl.TargetBase
}

func (t *NFloat64Target) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToFloat64(src)
	if err != nil {
		return err
	}
	*t.Value = NFloat64(val)

	return nil
}
func (t *NFloat64Target) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToFloat64(src)
	if err != nil {
		return err
	}
	*t.Value = NFloat64(val)

	return nil
}
func (t *NFloat64Target) FromFloat(src float64, tt *vdl.Type) error {

	*t.Value = NFloat64(src)

	return nil
}

type NArray2Uint64 [2]uint64

func (NArray2Uint64) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NArray2Uint64"`
}) {
}

func (m *NArray2Uint64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, 2)
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}
		if err := elemTarget2.FromUint(uint64(elem3), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *NArray2Uint64) MakeVDLTarget() vdl.Target {
	return &NArray2Uint64Target{Value: m}
}

// NArray2Uint64
type NArray2Uint64Target struct {
	Value      *NArray2Uint64
	elemTarget vdl.Uint64Target
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *NArray2Uint64Target) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*NArray2Uint64)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *NArray2Uint64Target) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *NArray2Uint64Target) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *NArray2Uint64Target) FinishList(elem vdl.ListTarget) error {

	return nil
}

type NListUint64 []uint64

func (NListUint64) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NListUint64"`
}) {
}

func (m *NListUint64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}
		if err := elemTarget2.FromUint(uint64(elem3), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *NListUint64) MakeVDLTarget() vdl.Target {
	return &NListUint64Target{Value: m}
}

// NListUint64
type NListUint64Target struct {
	Value      *NListUint64
	elemTarget vdl.Uint64Target
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *NListUint64Target) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*NListUint64)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(NListUint64, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *NListUint64Target) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *NListUint64Target) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *NListUint64Target) FinishList(elem vdl.ListTarget) error {

	return nil
}

type NSetUint64 map[uint64]struct{}

func (NSetUint64) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NSetUint64"`
}) {
}

func (m *NSetUint64) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	setTarget1, err := t.StartSet(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3 := range *m {
		keyTarget2, err := setTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromUint(uint64(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		if err := setTarget1.FinishKey(keyTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishSet(setTarget1); err != nil {
		return err
	}
	return nil
}

func (m *NSetUint64) MakeVDLTarget() vdl.Target {
	return &NSetUint64Target{Value: m}
}

type NSetUint64Target struct {
	Value     *NSetUint64
	currKey   uint64
	keyTarget vdl.Uint64Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *NSetUint64Target) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*NSetUint64)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(NSetUint64)
	return t, nil
}
func (t *NSetUint64Target) StartKey() (key vdl.Target, _ error) {
	t.currKey = uint64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *NSetUint64Target) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *NSetUint64Target) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type NMapUint64String map[uint64]string

func (NMapUint64String) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NMapUint64String"`
}) {
}

func (m *NMapUint64String) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	mapTarget1, err := t.StartMap(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3, value5 := range *m {
		keyTarget2, err := mapTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromUint(uint64(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		valueTarget4, err := mapTarget1.FinishKeyStartField(keyTarget2)
		if err != nil {
			return err
		}
		if err := valueTarget4.FromString(string(value5), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := mapTarget1.FinishField(keyTarget2, valueTarget4); err != nil {
			return err
		}
	}
	if err := t.FinishMap(mapTarget1); err != nil {
		return err
	}
	return nil
}

func (m *NMapUint64String) MakeVDLTarget() vdl.Target {
	return &NMapUint64StringTarget{Value: m}
}

type NMapUint64StringTarget struct {
	Value      *NMapUint64String
	currKey    uint64
	currElem   string
	keyTarget  vdl.Uint64Target
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *NMapUint64StringTarget) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*NMapUint64String)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(NMapUint64String)
	return t, nil
}
func (t *NMapUint64StringTarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = uint64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *NMapUint64StringTarget) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *NMapUint64StringTarget) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *NMapUint64StringTarget) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type NStruct struct {
	A bool
	B string
	C int64
}

func (NStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NStruct"`
}) {
}

func (m *NStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromString(string(m.B), tt.NonOptional().Field(1).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("C")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget7.FromInt(int64(m.C), tt.NonOptional().Field(2).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *NStruct) MakeVDLTarget() vdl.Target {
	return &NStructTarget{Value: m}
}

type NStructTarget struct {
	Value   *NStruct
	aTarget vdl.BoolTarget
	bTarget vdl.StringTarget
	cTarget vdl.Int64Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *NStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*NStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *NStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "A":
		t.aTarget.Value = &t.Value.A
		target, err := &t.aTarget, error(nil)
		return nil, target, err
	case "B":
		t.bTarget.Value = &t.Value.B
		target, err := &t.bTarget, error(nil)
		return nil, target, err
	case "C":
		t.cTarget.Value = &t.Value.C
		target, err := &t.cTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.NStruct", name)
	}
}
func (t *NStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *NStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type NEnum int

const (
	NEnumA NEnum = iota
	NEnumB
	NEnumC
)

// NEnumAll holds all labels for NEnum.
var NEnumAll = [...]NEnum{NEnumA, NEnumB, NEnumC}

// NEnumFromString creates a NEnum from a string label.
func NEnumFromString(label string) (x NEnum, err error) {
	err = x.Set(label)
	return
}

// Set assigns label to x.
func (x *NEnum) Set(label string) error {
	switch label {
	case "A", "a":
		*x = NEnumA
		return nil
	case "B", "b":
		*x = NEnumB
		return nil
	case "C", "c":
		*x = NEnumC
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in types.NEnum", label)
}

// String returns the string label of x.
func (x NEnum) String() string {
	switch x {
	case NEnumA:
		return "A"
	case NEnumB:
		return "B"
	case NEnumC:
		return "C"
	}
	return ""
}

func (NEnum) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.NEnum"`
	Enum struct{ A, B, C string }
}) {
}

func (m *NEnum) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), tt); err != nil {
		return err
	}
	return nil
}

func (m *NEnum) MakeVDLTarget() vdl.Target {
	return &NEnumTarget{Value: m}
}

type NEnumTarget struct {
	Value *NEnum
	vdl.TargetBase
}

func (t *NEnumTarget) FromEnumLabel(src string, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*NEnum)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	switch src {
	case "A":
		*t.Value = 0
	case "B":
		*t.Value = 1
	case "C":
		*t.Value = 2
	default:
		return fmt.Errorf("label %s not in enum v.io/v23/vom/testdata/types.NEnum", src)
	}

	return nil
}

type (
	// NUnion represents any single field of the NUnion union type.
	NUnion interface {
		// Index returns the field index.
		Index() int
		// Interface returns the field value as an interface.
		Interface() interface{}
		// Name returns the field name.
		Name() string
		// __VDLReflect describes the NUnion union type.
		__VDLReflect(__NUnionReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
	}
	// NUnionA represents field A of the NUnion union type.
	NUnionA struct{ Value bool }
	// NUnionB represents field B of the NUnion union type.
	NUnionB struct{ Value string }
	// NUnionC represents field C of the NUnion union type.
	NUnionC struct{ Value int64 }
	// __NUnionReflect describes the NUnion union type.
	__NUnionReflect struct {
		Name               string `vdl:"v.io/v23/vom/testdata/types.NUnion"`
		Type               NUnion
		UnionTargetFactory nUnionTargetFactory
		Union              struct {
			A NUnionA
			B NUnionB
			C NUnionC
		}
	}
)

func (x NUnionA) Index() int                   { return 0 }
func (x NUnionA) Interface() interface{}       { return x.Value }
func (x NUnionA) Name() string                 { return "A" }
func (x NUnionA) __VDLReflect(__NUnionReflect) {}

func (m NUnionA) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromBool(bool(m.Value), tt.NonOptional().Field(0).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m NUnionA) MakeVDLTarget() vdl.Target {
	return nil
}

func (x NUnionB) Index() int                   { return 1 }
func (x NUnionB) Interface() interface{}       { return x.Value }
func (x NUnionB) Name() string                 { return "B" }
func (x NUnionB) __VDLReflect(__NUnionReflect) {}

func (m NUnionB) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromString(string(m.Value), tt.NonOptional().Field(1).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m NUnionB) MakeVDLTarget() vdl.Target {
	return nil
}

func (x NUnionC) Index() int                   { return 2 }
func (x NUnionC) Interface() interface{}       { return x.Value }
func (x NUnionC) Name() string                 { return "C" }
func (x NUnionC) __VDLReflect(__NUnionReflect) {}

func (m NUnionC) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("C")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(2).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m NUnionC) MakeVDLTarget() vdl.Target {
	return nil
}

type NUnionTarget struct {
	Value     *NUnion
	fieldName string

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *NUnionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if ttWant := vdl.TypeOf((*NUnion)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}

	return t, nil
}
func (t *NUnionTarget) StartField(name string) (key, field vdl.Target, _ error) {
	t.fieldName = name
	switch name {
	case "A":
		val := false
		return nil, &vdl.BoolTarget{Value: &val}, nil
	case "B":
		val := ""
		return nil, &vdl.StringTarget{Value: &val}, nil
	case "C":
		val := int64(0)
		return nil, &vdl.Int64Target{Value: &val}, nil
	default:
		return nil, nil, fmt.Errorf("field %s not in union v.io/v23/vom/testdata/types.NUnion", name)
	}
}
func (t *NUnionTarget) FinishField(_, fieldTarget vdl.Target) error {
	switch t.fieldName {
	case "A":
		*t.Value = NUnionA{*(fieldTarget.(*vdl.BoolTarget)).Value}
	case "B":
		*t.Value = NUnionB{*(fieldTarget.(*vdl.StringTarget)).Value}
	case "C":
		*t.Value = NUnionC{*(fieldTarget.(*vdl.Int64Target)).Value}
	}
	return nil
}
func (t *NUnionTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type nUnionTargetFactory struct{}

func (t nUnionTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
	if typedUnion, ok := union.(*NUnion); ok {
		return &NUnionTarget{Value: typedUnion}, nil
	}
	return nil, fmt.Errorf("got %T, want *NUnion", union)
}

// Nested Custom Types
type MBool NBool

func (MBool) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MBool"`
}) {
}

func (m *MBool) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromBool(bool((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *MBool) MakeVDLTarget() vdl.Target {
	return &MBoolTarget{Value: m}
}

type MBoolTarget struct {
	Value *MBool
	vdl.TargetBase
}

func (t *MBoolTarget) FromBool(src bool, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*MBool)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = MBool(src)

	return nil
}

type MStruct struct {
	A bool
	B NBool
	C MBool
	D *NStruct
	E *vdl.Type
	F *vdl.Value
}

func (MStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MStruct"`
}) {
}

func (m *MStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.B.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("C")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.C.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("D")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.D == nil {
			if err := fieldTarget9.FromNil(tt.NonOptional().Field(3).Type); err != nil {
				return err
			}
		} else {
			if err := m.D.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
			return err
		}
	}
	keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("E")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		typeObjectVal12 := m.E
		if typeObjectVal12 == nil {
			typeObjectVal12 = vdl.AnyType
		}
		if err := fieldTarget11.FromTypeObject(typeObjectVal12); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
			return err
		}
	}
	keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("F")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.F == nil {
			if err := fieldTarget14.FromNil(tt.NonOptional().Field(5).Type); err != nil {
				return err
			}
		} else {
			if err := vdl.FromValue(fieldTarget14, m.F); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MStruct) MakeVDLTarget() vdl.Target {
	return &MStructTarget{Value: m}
}

type MStructTarget struct {
	Value   *MStruct
	aTarget vdl.BoolTarget
	bTarget NBoolTarget
	cTarget MBoolTarget
	dTarget __VDLTarget7_optional
	eTarget vdl.TypeObjectTarget

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *MStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*MStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *MStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "A":
		t.aTarget.Value = &t.Value.A
		target, err := &t.aTarget, error(nil)
		return nil, target, err
	case "B":
		t.bTarget.Value = &t.Value.B
		target, err := &t.bTarget, error(nil)
		return nil, target, err
	case "C":
		t.cTarget.Value = &t.Value.C
		target, err := &t.cTarget, error(nil)
		return nil, target, err
	case "D":
		t.dTarget.Value = &t.Value.D
		target, err := &t.dTarget, error(nil)
		return nil, target, err
	case "E":
		t.eTarget.Value = &t.Value.E
		target, err := &t.eTarget, error(nil)
		return nil, target, err
	case "F":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.F))
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.MStruct", name)
	}
}
func (t *MStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *MStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// Optional NStruct
type __VDLTarget7_optional struct {
	Value      **NStruct
	elemTarget NStructTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *__VDLTarget7_optional) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if *t.Value == nil {
		*t.Value = &NStruct{}
	}
	t.elemTarget.Value = *t.Value
	target, err := &t.elemTarget, error(nil)
	if err != nil {
		return nil, err
	}
	return target.StartFields(tt)
}
func (t *__VDLTarget7_optional) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *__VDLTarget7_optional) FromNil(tt *vdl.Type) error {

	*t.Value = nil

	return nil
}

type MList []NListUint64

func (MList) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MList"`
}) {
}

func (m *MList) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}

		if err := elem3.FillVDLTarget(elemTarget2, tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MList) MakeVDLTarget() vdl.Target {
	return &MListTarget{Value: m}
}

// MList
type MListTarget struct {
	Value      *MList
	elemTarget NListUint64Target
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *MListTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*MList)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(MList, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *MListTarget) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *MListTarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *MListTarget) FinishList(elem vdl.ListTarget) error {

	return nil
}

type MMap map[NFloat32]NListUint64

func (MMap) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MMap"`
}) {
}

func (m *MMap) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	mapTarget1, err := t.StartMap(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3, value5 := range *m {
		keyTarget2, err := mapTarget1.StartKey()
		if err != nil {
			return err
		}

		if err := key3.FillVDLTarget(keyTarget2, tt.NonOptional().Key()); err != nil {
			return err
		}
		valueTarget4, err := mapTarget1.FinishKeyStartField(keyTarget2)
		if err != nil {
			return err
		}

		if err := value5.FillVDLTarget(valueTarget4, tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := mapTarget1.FinishField(keyTarget2, valueTarget4); err != nil {
			return err
		}
	}
	if err := t.FinishMap(mapTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MMap) MakeVDLTarget() vdl.Target {
	return &MMapTarget{Value: m}
}

type MMapTarget struct {
	Value      *MMap
	currKey    NFloat32
	currElem   NListUint64
	keyTarget  NFloat32Target
	elemTarget NListUint64Target
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *MMapTarget) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*MMap)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(MMap)
	return t, nil
}
func (t *MMapTarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = NFloat32(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *MMapTarget) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = NListUint64(nil)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *MMapTarget) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *MMapTarget) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type MByteSlice []byte

func (MByteSlice) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MByteSlice"`
}) {
}

func (m *MByteSlice) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromBytes([]byte((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *MByteSlice) MakeVDLTarget() vdl.Target {
	return &MByteSliceTarget{Value: m}
}

type MByteSliceTarget struct {
	Value *MByteSlice
	vdl.TargetBase
}

func (t *MByteSliceTarget) FromBytes(src []byte, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*MByteSlice)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if len(src) == 0 {
		*t.Value = nil
	} else {
		*t.Value = make([]byte, len(src))
		copy(*t.Value, src)
	}

	return nil
}

type MInt8Slice []int8

func (MInt8Slice) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MInt8Slice"`
}) {
}

func (m *MInt8Slice) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}
		if err := elemTarget2.FromInt(int64(elem3), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MInt8Slice) MakeVDLTarget() vdl.Target {
	return &MInt8SliceTarget{Value: m}
}

// MInt8Slice
type MInt8SliceTarget struct {
	Value      *MInt8Slice
	elemTarget vdl.Int8Target
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *MInt8SliceTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*MInt8Slice)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(MInt8Slice, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *MInt8SliceTarget) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *MInt8SliceTarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *MInt8SliceTarget) FinishList(elem vdl.ListTarget) error {

	return nil
}

// Recursive Type Definitions
type RecA []RecA

func (RecA) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.RecA"`
}) {
}

func (m *RecA) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}

		if err := elem3.FillVDLTarget(elemTarget2, tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *RecA) MakeVDLTarget() vdl.Target {
	return &RecATarget{Value: m}
}

// RecA
type RecATarget struct {
	Value *RecA

	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *RecATarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*RecA)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(RecA, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *RecATarget) StartElem(index int) (elem vdl.Target, _ error) {
	target, err := &RecATarget{Value: &(*t.Value)[index]}, error(nil)
	return target, err
}
func (t *RecATarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *RecATarget) FinishList(elem vdl.ListTarget) error {

	return nil
}

type RecY []RecX

func (RecY) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.RecY"`
}) {
}

func (m *RecY) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}

		if err := elem3.FillVDLTarget(elemTarget2, tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *RecY) MakeVDLTarget() vdl.Target {
	return &RecYTarget{Value: m}
}

// RecY
type RecYTarget struct {
	Value *RecY

	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *RecYTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*RecY)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(RecY, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *RecYTarget) StartElem(index int) (elem vdl.Target, _ error) {
	target, err := &RecXTarget{Value: &(*t.Value)[index]}, error(nil)
	return target, err
}
func (t *RecYTarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *RecYTarget) FinishList(elem vdl.ListTarget) error {

	return nil
}

// RecX
type RecXTarget struct {
	Value *RecX

	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *RecXTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*RecX)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(RecX, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *RecXTarget) StartElem(index int) (elem vdl.Target, _ error) {
	target, err := &RecYTarget{Value: &(*t.Value)[index]}, error(nil)
	return target, err
}
func (t *RecXTarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *RecXTarget) FinishList(elem vdl.ListTarget) error {

	return nil
}

type RecX []RecY

func (RecX) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.RecX"`
}) {
}

func (m *RecX) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}

		if err := elem3.FillVDLTarget(elemTarget2, tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *RecX) MakeVDLTarget() vdl.Target {
	return &RecXTarget{Value: m}
}

type Rec4 []Rec1

func (Rec4) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.Rec4"`
}) {
}

func (m *Rec4) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}

		if err := elem3.FillVDLTarget(elemTarget2, tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Rec4) MakeVDLTarget() vdl.Target {
	return &Rec4Target{Value: m}
}

// Rec4
type Rec4Target struct {
	Value *Rec4

	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *Rec4Target) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*Rec4)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(Rec4, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *Rec4Target) StartElem(index int) (elem vdl.Target, _ error) {
	target, err := &Rec1Target{Value: &(*t.Value)[index]}, error(nil)
	return target, err
}
func (t *Rec4Target) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *Rec4Target) FinishList(elem vdl.ListTarget) error {

	return nil
}

// Rec1
type Rec1Target struct {
	Value *Rec1

	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *Rec1Target) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*Rec1)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(Rec1, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *Rec1Target) StartElem(index int) (elem vdl.Target, _ error) {
	target, err := &Rec2Target{Value: &(*t.Value)[index]}, error(nil)
	return target, err
}
func (t *Rec1Target) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *Rec1Target) FinishList(elem vdl.ListTarget) error {

	return nil
}

// Rec2
type Rec2Target struct {
	Value *Rec2

	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *Rec2Target) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*Rec2)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(Rec2, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *Rec2Target) StartElem(index int) (elem vdl.Target, _ error) {
	target, err := &Rec3Target{Value: &(*t.Value)[index]}, error(nil)
	return target, err
}
func (t *Rec2Target) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *Rec2Target) FinishList(elem vdl.ListTarget) error {

	return nil
}

// Rec3
type Rec3Target struct {
	Value *Rec3

	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *Rec3Target) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*Rec3)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(Rec3, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *Rec3Target) StartElem(index int) (elem vdl.Target, _ error) {
	target, err := &Rec4Target{Value: &(*t.Value)[index]}, error(nil)
	return target, err
}
func (t *Rec3Target) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *Rec3Target) FinishList(elem vdl.ListTarget) error {

	return nil
}

type Rec3 []Rec4

func (Rec3) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.Rec3"`
}) {
}

func (m *Rec3) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}

		if err := elem3.FillVDLTarget(elemTarget2, tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Rec3) MakeVDLTarget() vdl.Target {
	return &Rec3Target{Value: m}
}

type Rec2 []Rec3

func (Rec2) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.Rec2"`
}) {
}

func (m *Rec2) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}

		if err := elem3.FillVDLTarget(elemTarget2, tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Rec2) MakeVDLTarget() vdl.Target {
	return &Rec2Target{Value: m}
}

type Rec1 []Rec2

func (Rec1) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.Rec1"`
}) {
}

func (m *Rec1) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}

		if err := elem3.FillVDLTarget(elemTarget2, tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Rec1) MakeVDLTarget() vdl.Target {
	return &Rec1Target{Value: m}
}

type RecStruct struct {
	A *RecStruct
}

func (RecStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.RecStruct"`
}) {
}

func (m *RecStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.A == nil {
			if err := fieldTarget3.FromNil(tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
		} else {
			if err := m.A.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *RecStruct) MakeVDLTarget() vdl.Target {
	return &RecStructTarget{Value: m}
}

type RecStructTarget struct {
	Value *RecStruct

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *RecStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*RecStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *RecStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "A":
		target, err := &__VDLTarget8_optional{Value: &t.Value.A}, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.RecStruct", name)
	}
}
func (t *RecStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *RecStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// Optional RecStruct
type __VDLTarget8_optional struct {
	Value **RecStruct

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *__VDLTarget8_optional) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if *t.Value == nil {
		*t.Value = &RecStruct{}
	}
	target, err := &RecStructTarget{Value: *t.Value}, error(nil)
	if err != nil {
		return nil, err
	}
	return target.StartFields(tt)
}
func (t *__VDLTarget8_optional) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *__VDLTarget8_optional) FromNil(tt *vdl.Type) error {

	*t.Value = nil

	return nil
}

type Rec1234 struct {
	R1 Rec1
	R2 Rec2
	R3 Rec3
	R4 Rec4
}

func (Rec1234) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.Rec1234"`
}) {
}

func (m *Rec1234) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("R1")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.R1.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("R2")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.R2.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("R3")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.R3.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("R4")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.R4.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Rec1234) MakeVDLTarget() vdl.Target {
	return &Rec1234Target{Value: m}
}

type Rec1234Target struct {
	Value    *Rec1234
	r1Target Rec1Target
	r2Target Rec2Target
	r3Target Rec3Target
	r4Target Rec4Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *Rec1234Target) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Rec1234)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *Rec1234Target) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "R1":
		t.r1Target.Value = &t.Value.R1
		target, err := &t.r1Target, error(nil)
		return nil, target, err
	case "R2":
		t.r2Target.Value = &t.Value.R2
		target, err := &t.r2Target, error(nil)
		return nil, target, err
	case "R3":
		t.r3Target.Value = &t.Value.R3
		target, err := &t.r3Target, error(nil)
		return nil, target, err
	case "R4":
		t.r4Target.Value = &t.Value.R4
		target, err := &t.r4Target, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.Rec1234", name)
	}
}
func (t *Rec1234Target) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *Rec1234Target) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type Rec1234A struct {
	A       []Rec1234A
	Rec1234 []Rec1234
}

func (Rec1234A) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.Rec1234A"`
}) {
}

func (m *Rec1234A) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.A))
		if err != nil {
			return err
		}
		for i, elem6 := range m.A {
			elemTarget5, err := listTarget4.StartElem(i)
			if err != nil {
				return err
			}

			if err := elem6.FillVDLTarget(elemTarget5, tt.NonOptional().Field(0).Type.Elem()); err != nil {
				return err
			}
			if err := listTarget4.FinishElem(elemTarget5); err != nil {
				return err
			}
		}
		if err := fieldTarget3.FinishList(listTarget4); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Rec1234")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		listTarget9, err := fieldTarget8.StartList(tt.NonOptional().Field(1).Type, len(m.Rec1234))
		if err != nil {
			return err
		}
		for i, elem11 := range m.Rec1234 {
			elemTarget10, err := listTarget9.StartElem(i)
			if err != nil {
				return err
			}

			if err := elem11.FillVDLTarget(elemTarget10, tt.NonOptional().Field(1).Type.Elem()); err != nil {
				return err
			}
			if err := listTarget9.FinishElem(elemTarget10); err != nil {
				return err
			}
		}
		if err := fieldTarget8.FinishList(listTarget9); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Rec1234A) MakeVDLTarget() vdl.Target {
	return &Rec1234ATarget{Value: m}
}

type Rec1234ATarget struct {
	Value *Rec1234A

	rec1234Target __VDLTarget9_list
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *Rec1234ATarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Rec1234A)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *Rec1234ATarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "A":
		target, err := &__VDLTarget10_list{Value: &t.Value.A}, error(nil)
		return nil, target, err
	case "Rec1234":
		t.rec1234Target.Value = &t.Value.Rec1234
		target, err := &t.rec1234Target, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.Rec1234A", name)
	}
}
func (t *Rec1234ATarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *Rec1234ATarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// []Rec1234A
type __VDLTarget10_list struct {
	Value *[]Rec1234A

	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget10_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]Rec1234A)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]Rec1234A, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget10_list) StartElem(index int) (elem vdl.Target, _ error) {
	target, err := &Rec1234ATarget{Value: &(*t.Value)[index]}, error(nil)
	return target, err
}
func (t *__VDLTarget10_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget10_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

// []Rec1234
type __VDLTarget9_list struct {
	Value      *[]Rec1234
	elemTarget Rec1234Target
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget9_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]Rec1234)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]Rec1234, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget9_list) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget9_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget9_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

type Rec1234B struct {
	B       []Rec1234B
	Rec1234 []Rec1234
}

func (Rec1234B) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.Rec1234B"`
}) {
}

func (m *Rec1234B) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.B))
		if err != nil {
			return err
		}
		for i, elem6 := range m.B {
			elemTarget5, err := listTarget4.StartElem(i)
			if err != nil {
				return err
			}

			if err := elem6.FillVDLTarget(elemTarget5, tt.NonOptional().Field(0).Type.Elem()); err != nil {
				return err
			}
			if err := listTarget4.FinishElem(elemTarget5); err != nil {
				return err
			}
		}
		if err := fieldTarget3.FinishList(listTarget4); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Rec1234")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		listTarget9, err := fieldTarget8.StartList(tt.NonOptional().Field(1).Type, len(m.Rec1234))
		if err != nil {
			return err
		}
		for i, elem11 := range m.Rec1234 {
			elemTarget10, err := listTarget9.StartElem(i)
			if err != nil {
				return err
			}

			if err := elem11.FillVDLTarget(elemTarget10, tt.NonOptional().Field(1).Type.Elem()); err != nil {
				return err
			}
			if err := listTarget9.FinishElem(elemTarget10); err != nil {
				return err
			}
		}
		if err := fieldTarget8.FinishList(listTarget9); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Rec1234B) MakeVDLTarget() vdl.Target {
	return &Rec1234BTarget{Value: m}
}

type Rec1234BTarget struct {
	Value *Rec1234B

	rec1234Target __VDLTarget9_list
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *Rec1234BTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Rec1234B)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *Rec1234BTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "B":
		target, err := &__VDLTarget11_list{Value: &t.Value.B}, error(nil)
		return nil, target, err
	case "Rec1234":
		t.rec1234Target.Value = &t.Value.Rec1234
		target, err := &t.rec1234Target, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.Rec1234B", name)
	}
}
func (t *Rec1234BTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *Rec1234BTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// []Rec1234B
type __VDLTarget11_list struct {
	Value *[]Rec1234B

	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget11_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]Rec1234B)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]Rec1234B, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget11_list) StartElem(index int) (elem vdl.Target, _ error) {
	target, err := &Rec1234BTarget{Value: &(*t.Value)[index]}, error(nil)
	return target, err
}
func (t *__VDLTarget11_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget11_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

type Rec1234All struct {
	A Rec1234A
	B Rec1234B
}

func (Rec1234All) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.Rec1234All"`
}) {
}

func (m *Rec1234All) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.A.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.B.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Rec1234All) MakeVDLTarget() vdl.Target {
	return &Rec1234AllTarget{Value: m}
}

type Rec1234AllTarget struct {
	Value   *Rec1234All
	aTarget Rec1234ATarget
	bTarget Rec1234BTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *Rec1234AllTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*Rec1234All)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *Rec1234AllTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "A":
		t.aTarget.Value = &t.Value.A
		target, err := &t.aTarget, error(nil)
		return nil, target, err
	case "B":
		t.bTarget.Value = &t.Value.B
		target, err := &t.bTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.Rec1234All", name)
	}
}
func (t *Rec1234AllTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *Rec1234AllTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// Additional types for compatibility and conversion checks
type ListString []string

func (ListString) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.ListString"`
}) {
}

func (m *ListString) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}
		if err := elemTarget2.FromString(string(elem3), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *ListString) MakeVDLTarget() vdl.Target {
	return &ListStringTarget{Value: m}
}

// ListString
type ListStringTarget struct {
	Value      *ListString
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *ListStringTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*ListString)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(ListString, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *ListStringTarget) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *ListStringTarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *ListStringTarget) FinishList(elem vdl.ListTarget) error {

	return nil
}

type Array3String [3]string

func (Array3String) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.Array3String"`
}) {
}

func (m *Array3String) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, 3)
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}
		if err := elemTarget2.FromString(string(elem3), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Array3String) MakeVDLTarget() vdl.Target {
	return &Array3StringTarget{Value: m}
}

// Array3String
type Array3StringTarget struct {
	Value      *Array3String
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *Array3StringTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*Array3String)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *Array3StringTarget) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *Array3StringTarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *Array3StringTarget) FinishList(elem vdl.ListTarget) error {

	return nil
}

type Array4String [4]string

func (Array4String) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.Array4String"`
}) {
}

func (m *Array4String) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, 4)
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}
		if err := elemTarget2.FromString(string(elem3), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Array4String) MakeVDLTarget() vdl.Target {
	return &Array4StringTarget{Value: m}
}

// Array4String
type Array4StringTarget struct {
	Value      *Array4String
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *Array4StringTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*Array4String)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *Array4StringTarget) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *Array4StringTarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *Array4StringTarget) FinishList(elem vdl.ListTarget) error {

	return nil
}

type AbcStruct struct {
	A bool
	B string
	C int64
}

func (AbcStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.AbcStruct"`
}) {
}

func (m *AbcStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromString(string(m.B), tt.NonOptional().Field(1).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("C")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget7.FromInt(int64(m.C), tt.NonOptional().Field(2).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *AbcStruct) MakeVDLTarget() vdl.Target {
	return &AbcStructTarget{Value: m}
}

type AbcStructTarget struct {
	Value   *AbcStruct
	aTarget vdl.BoolTarget
	bTarget vdl.StringTarget
	cTarget vdl.Int64Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *AbcStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*AbcStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *AbcStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "A":
		t.aTarget.Value = &t.Value.A
		target, err := &t.aTarget, error(nil)
		return nil, target, err
	case "B":
		t.bTarget.Value = &t.Value.B
		target, err := &t.bTarget, error(nil)
		return nil, target, err
	case "C":
		t.cTarget.Value = &t.Value.C
		target, err := &t.cTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.AbcStruct", name)
	}
}
func (t *AbcStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *AbcStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type AdeStruct struct {
	A bool
	D *vdl.Value
	E *vdl.Type
}

func (AdeStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.AdeStruct"`
}) {
}

func (m *AdeStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("D")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.D == nil {
			if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		} else {
			if err := vdl.FromValue(fieldTarget5, m.D); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("E")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		typeObjectVal8 := m.E
		if typeObjectVal8 == nil {
			typeObjectVal8 = vdl.AnyType
		}
		if err := fieldTarget7.FromTypeObject(typeObjectVal8); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *AdeStruct) MakeVDLTarget() vdl.Target {
	return &AdeStructTarget{Value: m}
}

type AdeStructTarget struct {
	Value   *AdeStruct
	aTarget vdl.BoolTarget

	eTarget vdl.TypeObjectTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *AdeStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*AdeStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *AdeStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "A":
		t.aTarget.Value = &t.Value.A
		target, err := &t.aTarget, error(nil)
		return nil, target, err
	case "D":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.D))
		return nil, target, err
	case "E":
		t.eTarget.Value = &t.Value.E
		target, err := &t.eTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.AdeStruct", name)
	}
}
func (t *AdeStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *AdeStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type XyzStruct struct {
	X bool
	Y MBool
	Z string
}

func (XyzStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.XyzStruct"`
}) {
}

func (m *XyzStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("X")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromBool(bool(m.X), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Y")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Y.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Z")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget7.FromString(string(m.Z), tt.NonOptional().Field(2).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *XyzStruct) MakeVDLTarget() vdl.Target {
	return &XyzStructTarget{Value: m}
}

type XyzStructTarget struct {
	Value   *XyzStruct
	xTarget vdl.BoolTarget
	yTarget MBoolTarget
	zTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *XyzStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*XyzStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *XyzStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "X":
		t.xTarget.Value = &t.Value.X
		target, err := &t.xTarget, error(nil)
		return nil, target, err
	case "Y":
		t.yTarget.Value = &t.Value.Y
		target, err := &t.yTarget, error(nil)
		return nil, target, err
	case "Z":
		t.zTarget.Value = &t.Value.Z
		target, err := &t.zTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.XyzStruct", name)
	}
}
func (t *XyzStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *XyzStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type YzStruct struct {
	Y NBool
	Z NString
}

func (YzStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.YzStruct"`
}) {
}

func (m *YzStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Y")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Y.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Z")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Z.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *YzStruct) MakeVDLTarget() vdl.Target {
	return &YzStructTarget{Value: m}
}

type YzStructTarget struct {
	Value   *YzStruct
	yTarget NBoolTarget
	zTarget NStringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *YzStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*YzStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *YzStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Y":
		t.yTarget.Value = &t.Value.Y
		target, err := &t.yTarget, error(nil)
		return nil, target, err
	case "Z":
		t.zTarget.Value = &t.Value.Z
		target, err := &t.zTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.YzStruct", name)
	}
}
func (t *YzStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *YzStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type ZStruct struct {
	Z string
}

func (ZStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.ZStruct"`
}) {
}

func (m *ZStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Z")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Z), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *ZStruct) MakeVDLTarget() vdl.Target {
	return &ZStructTarget{Value: m}
}

type ZStructTarget struct {
	Value   *ZStruct
	zTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ZStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*ZStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *ZStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Z":
		t.zTarget.Value = &t.Value.Z
		target, err := &t.zTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.ZStruct", name)
	}
}
func (t *ZStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ZStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type MapOnlyStruct struct {
	Key1 int64
	Key2 uint32
}

func (MapOnlyStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlyStruct"`
}) {
}

func (m *MapOnlyStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key1")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromInt(int64(m.Key1), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Key2")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromUint(uint64(m.Key2), tt.NonOptional().Field(1).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MapOnlyStruct) MakeVDLTarget() vdl.Target {
	return &MapOnlyStructTarget{Value: m}
}

type MapOnlyStructTarget struct {
	Value      *MapOnlyStruct
	key1Target vdl.Int64Target
	key2Target vdl.Uint32Target
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *MapOnlyStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*MapOnlyStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *MapOnlyStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Key1":
		t.key1Target.Value = &t.Value.Key1
		target, err := &t.key1Target, error(nil)
		return nil, target, err
	case "Key2":
		t.key2Target.Value = &t.Value.Key2
		target, err := &t.key2Target, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.MapOnlyStruct", name)
	}
}
func (t *MapOnlyStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *MapOnlyStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type StructOnlyMap map[string]uint64

func (StructOnlyMap) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.StructOnlyMap"`
}) {
}

func (m *StructOnlyMap) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	mapTarget1, err := t.StartMap(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3, value5 := range *m {
		keyTarget2, err := mapTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromString(string(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		valueTarget4, err := mapTarget1.FinishKeyStartField(keyTarget2)
		if err != nil {
			return err
		}
		if err := valueTarget4.FromUint(uint64(value5), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := mapTarget1.FinishField(keyTarget2, valueTarget4); err != nil {
			return err
		}
	}
	if err := t.FinishMap(mapTarget1); err != nil {
		return err
	}
	return nil
}

func (m *StructOnlyMap) MakeVDLTarget() vdl.Target {
	return &StructOnlyMapTarget{Value: m}
}

type StructOnlyMapTarget struct {
	Value      *StructOnlyMap
	currKey    string
	currElem   uint64
	keyTarget  vdl.StringTarget
	elemTarget vdl.Uint64Target
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *StructOnlyMapTarget) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*StructOnlyMap)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(StructOnlyMap)
	return t, nil
}
func (t *StructOnlyMapTarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = ""
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *StructOnlyMapTarget) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = uint64(0)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *StructOnlyMapTarget) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *StructOnlyMapTarget) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type MapSetStruct struct {
	Feat bool
	Tire bool
	Eel  bool
}

func (MapSetStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MapSetStruct"`
}) {
}

func (m *MapSetStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Feat")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromBool(bool(m.Feat), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Tire")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromBool(bool(m.Tire), tt.NonOptional().Field(1).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Eel")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget7.FromBool(bool(m.Eel), tt.NonOptional().Field(2).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MapSetStruct) MakeVDLTarget() vdl.Target {
	return &MapSetStructTarget{Value: m}
}

type MapSetStructTarget struct {
	Value      *MapSetStruct
	featTarget vdl.BoolTarget
	tireTarget vdl.BoolTarget
	eelTarget  vdl.BoolTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *MapSetStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*MapSetStruct)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *MapSetStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Feat":
		t.featTarget.Value = &t.Value.Feat
		target, err := &t.featTarget, error(nil)
		return nil, target, err
	case "Tire":
		t.tireTarget.Value = &t.Value.Tire
		target, err := &t.tireTarget, error(nil)
		return nil, target, err
	case "Eel":
		t.eelTarget.Value = &t.Value.Eel
		target, err := &t.eelTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.MapSetStruct", name)
	}
}
func (t *MapSetStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *MapSetStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type SetStructMap map[string]bool

func (SetStructMap) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.SetStructMap"`
}) {
}

func (m *SetStructMap) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	mapTarget1, err := t.StartMap(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3, value5 := range *m {
		keyTarget2, err := mapTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromString(string(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		valueTarget4, err := mapTarget1.FinishKeyStartField(keyTarget2)
		if err != nil {
			return err
		}
		if err := valueTarget4.FromBool(bool(value5), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := mapTarget1.FinishField(keyTarget2, valueTarget4); err != nil {
			return err
		}
	}
	if err := t.FinishMap(mapTarget1); err != nil {
		return err
	}
	return nil
}

func (m *SetStructMap) MakeVDLTarget() vdl.Target {
	return &SetStructMapTarget{Value: m}
}

type SetStructMapTarget struct {
	Value      *SetStructMap
	currKey    string
	currElem   bool
	keyTarget  vdl.StringTarget
	elemTarget vdl.BoolTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *SetStructMapTarget) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*SetStructMap)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(SetStructMap)
	return t, nil
}
func (t *SetStructMapTarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = ""
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *SetStructMapTarget) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = false
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *SetStructMapTarget) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *SetStructMapTarget) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type MapStructSet map[string]struct{}

func (MapStructSet) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MapStructSet"`
}) {
}

func (m *MapStructSet) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	setTarget1, err := t.StartSet(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3 := range *m {
		keyTarget2, err := setTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromString(string(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		if err := setTarget1.FinishKey(keyTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishSet(setTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MapStructSet) MakeVDLTarget() vdl.Target {
	return &MapStructSetTarget{Value: m}
}

type MapStructSetTarget struct {
	Value     *MapStructSet
	currKey   string
	keyTarget vdl.StringTarget
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *MapStructSetTarget) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*MapStructSet)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(MapStructSet)
	return t, nil
}
func (t *MapStructSetTarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = ""
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *MapStructSetTarget) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *MapStructSetTarget) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type SetOnlyMap map[float64]bool

func (SetOnlyMap) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.SetOnlyMap"`
}) {
}

func (m *SetOnlyMap) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	mapTarget1, err := t.StartMap(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3, value5 := range *m {
		keyTarget2, err := mapTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromFloat(float64(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		valueTarget4, err := mapTarget1.FinishKeyStartField(keyTarget2)
		if err != nil {
			return err
		}
		if err := valueTarget4.FromBool(bool(value5), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := mapTarget1.FinishField(keyTarget2, valueTarget4); err != nil {
			return err
		}
	}
	if err := t.FinishMap(mapTarget1); err != nil {
		return err
	}
	return nil
}

func (m *SetOnlyMap) MakeVDLTarget() vdl.Target {
	return &SetOnlyMapTarget{Value: m}
}

type SetOnlyMapTarget struct {
	Value      *SetOnlyMap
	currKey    float64
	currElem   bool
	keyTarget  vdl.Float64Target
	elemTarget vdl.BoolTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *SetOnlyMapTarget) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*SetOnlyMap)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(SetOnlyMap)
	return t, nil
}
func (t *SetOnlyMapTarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = float64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *SetOnlyMapTarget) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = false
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *SetOnlyMapTarget) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *SetOnlyMapTarget) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type SometimesSetMap map[float64]*vdl.Value

func (SometimesSetMap) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.SometimesSetMap"`
}) {
}

func (m *SometimesSetMap) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	mapTarget1, err := t.StartMap(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3, value5 := range *m {
		keyTarget2, err := mapTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromFloat(float64(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		valueTarget4, err := mapTarget1.FinishKeyStartField(keyTarget2)
		if err != nil {
			return err
		}

		if value5 == nil {
			if err := valueTarget4.FromNil(tt.NonOptional().Elem()); err != nil {
				return err
			}
		} else {
			if err := vdl.FromValue(valueTarget4, value5); err != nil {
				return err
			}
		}
		if err := mapTarget1.FinishField(keyTarget2, valueTarget4); err != nil {
			return err
		}
	}
	if err := t.FinishMap(mapTarget1); err != nil {
		return err
	}
	return nil
}

func (m *SometimesSetMap) MakeVDLTarget() vdl.Target {
	return &SometimesSetMapTarget{Value: m}
}

type SometimesSetMapTarget struct {
	Value     *SometimesSetMap
	currKey   float64
	currElem  *vdl.Value
	keyTarget vdl.Float64Target

	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *SometimesSetMapTarget) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*SometimesSetMap)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(SometimesSetMap)
	return t, nil
}
func (t *SometimesSetMapTarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = float64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *SometimesSetMapTarget) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = (*vdl.Value)(nil)
	target, err := vdl.ReflectTarget(reflect.ValueOf(&t.currElem))
	return target, err
}
func (t *SometimesSetMapTarget) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *SometimesSetMapTarget) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type MapOnlySet map[float64]struct{}

func (MapOnlySet) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlySet"`
}) {
}

func (m *MapOnlySet) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	setTarget1, err := t.StartSet(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3 := range *m {
		keyTarget2, err := setTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromFloat(float64(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		if err := setTarget1.FinishKey(keyTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishSet(setTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MapOnlySet) MakeVDLTarget() vdl.Target {
	return &MapOnlySetTarget{Value: m}
}

type MapOnlySetTarget struct {
	Value     *MapOnlySet
	currKey   float64
	keyTarget vdl.Float64Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *MapOnlySetTarget) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*MapOnlySet)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(MapOnlySet)
	return t, nil
}
func (t *MapOnlySetTarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = float64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *MapOnlySetTarget) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *MapOnlySetTarget) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type SetOnlyA map[bool]struct{}

func (SetOnlyA) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.SetOnlyA"`
}) {
}

func (m *SetOnlyA) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	setTarget1, err := t.StartSet(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3 := range *m {
		keyTarget2, err := setTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromBool(bool(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		if err := setTarget1.FinishKey(keyTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishSet(setTarget1); err != nil {
		return err
	}
	return nil
}

func (m *SetOnlyA) MakeVDLTarget() vdl.Target {
	return &SetOnlyATarget{Value: m}
}

type SetOnlyATarget struct {
	Value     *SetOnlyA
	currKey   bool
	keyTarget vdl.BoolTarget
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *SetOnlyATarget) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*SetOnlyA)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(SetOnlyA)
	return t, nil
}
func (t *SetOnlyATarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = false
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *SetOnlyATarget) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *SetOnlyATarget) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type SetOnlyA2 map[NBool]struct{}

func (SetOnlyA2) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.SetOnlyA2"`
}) {
}

func (m *SetOnlyA2) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	setTarget1, err := t.StartSet(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3 := range *m {
		keyTarget2, err := setTarget1.StartKey()
		if err != nil {
			return err
		}

		if err := key3.FillVDLTarget(keyTarget2, tt.NonOptional().Key()); err != nil {
			return err
		}
		if err := setTarget1.FinishKey(keyTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishSet(setTarget1); err != nil {
		return err
	}
	return nil
}

func (m *SetOnlyA2) MakeVDLTarget() vdl.Target {
	return &SetOnlyA2Target{Value: m}
}

type SetOnlyA2Target struct {
	Value     *SetOnlyA2
	currKey   NBool
	keyTarget NBoolTarget
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *SetOnlyA2Target) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*SetOnlyA2)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(SetOnlyA2)
	return t, nil
}
func (t *SetOnlyA2Target) StartKey() (key vdl.Target, _ error) {
	t.currKey = NBool(false)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *SetOnlyA2Target) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *SetOnlyA2Target) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type SetOnlyB map[int16]struct{}

func (SetOnlyB) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.SetOnlyB"`
}) {
}

func (m *SetOnlyB) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	setTarget1, err := t.StartSet(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3 := range *m {
		keyTarget2, err := setTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromInt(int64(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		if err := setTarget1.FinishKey(keyTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishSet(setTarget1); err != nil {
		return err
	}
	return nil
}

func (m *SetOnlyB) MakeVDLTarget() vdl.Target {
	return &SetOnlyBTarget{Value: m}
}

type SetOnlyBTarget struct {
	Value     *SetOnlyB
	currKey   int16
	keyTarget vdl.Int16Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *SetOnlyBTarget) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*SetOnlyB)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(SetOnlyB)
	return t, nil
}
func (t *SetOnlyBTarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = int16(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *SetOnlyBTarget) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *SetOnlyBTarget) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type SetOnlyB2 map[NInt16]struct{}

func (SetOnlyB2) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.SetOnlyB2"`
}) {
}

func (m *SetOnlyB2) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	setTarget1, err := t.StartSet(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3 := range *m {
		keyTarget2, err := setTarget1.StartKey()
		if err != nil {
			return err
		}

		if err := key3.FillVDLTarget(keyTarget2, tt.NonOptional().Key()); err != nil {
			return err
		}
		if err := setTarget1.FinishKey(keyTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishSet(setTarget1); err != nil {
		return err
	}
	return nil
}

func (m *SetOnlyB2) MakeVDLTarget() vdl.Target {
	return &SetOnlyB2Target{Value: m}
}

type SetOnlyB2Target struct {
	Value     *SetOnlyB2
	currKey   NInt16
	keyTarget NInt16Target
	vdl.TargetBase
	vdl.SetTargetBase
}

func (t *SetOnlyB2Target) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {

	if ttWant := vdl.TypeOf((*SetOnlyB2)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(SetOnlyB2)
	return t, nil
}
func (t *SetOnlyB2Target) StartKey() (key vdl.Target, _ error) {
	t.currKey = NInt16(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *SetOnlyB2Target) FinishKey(key vdl.Target) error {
	(*t.Value)[t.currKey] = struct{}{}
	return nil
}
func (t *SetOnlyB2Target) FinishSet(list vdl.SetTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type MapOnlyA map[uint32]uint32

func (MapOnlyA) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlyA"`
}) {
}

func (m *MapOnlyA) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	mapTarget1, err := t.StartMap(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3, value5 := range *m {
		keyTarget2, err := mapTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromUint(uint64(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		valueTarget4, err := mapTarget1.FinishKeyStartField(keyTarget2)
		if err != nil {
			return err
		}
		if err := valueTarget4.FromUint(uint64(value5), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := mapTarget1.FinishField(keyTarget2, valueTarget4); err != nil {
			return err
		}
	}
	if err := t.FinishMap(mapTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MapOnlyA) MakeVDLTarget() vdl.Target {
	return &MapOnlyATarget{Value: m}
}

type MapOnlyATarget struct {
	Value      *MapOnlyA
	currKey    uint32
	currElem   uint32
	keyTarget  vdl.Uint32Target
	elemTarget vdl.Uint32Target
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *MapOnlyATarget) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*MapOnlyA)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(MapOnlyA)
	return t, nil
}
func (t *MapOnlyATarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = uint32(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *MapOnlyATarget) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = uint32(0)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *MapOnlyATarget) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *MapOnlyATarget) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type MapOnlyA2 map[int64]float64

func (MapOnlyA2) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlyA2"`
}) {
}

func (m *MapOnlyA2) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	mapTarget1, err := t.StartMap(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3, value5 := range *m {
		keyTarget2, err := mapTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromInt(int64(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		valueTarget4, err := mapTarget1.FinishKeyStartField(keyTarget2)
		if err != nil {
			return err
		}
		if err := valueTarget4.FromFloat(float64(value5), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := mapTarget1.FinishField(keyTarget2, valueTarget4); err != nil {
			return err
		}
	}
	if err := t.FinishMap(mapTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MapOnlyA2) MakeVDLTarget() vdl.Target {
	return &MapOnlyA2Target{Value: m}
}

type MapOnlyA2Target struct {
	Value      *MapOnlyA2
	currKey    int64
	currElem   float64
	keyTarget  vdl.Int64Target
	elemTarget vdl.Float64Target
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *MapOnlyA2Target) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*MapOnlyA2)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(MapOnlyA2)
	return t, nil
}
func (t *MapOnlyA2Target) StartKey() (key vdl.Target, _ error) {
	t.currKey = int64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *MapOnlyA2Target) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = float64(0)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *MapOnlyA2Target) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *MapOnlyA2Target) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type MapOnlyB map[bool]string

func (MapOnlyB) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlyB"`
}) {
}

func (m *MapOnlyB) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	mapTarget1, err := t.StartMap(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3, value5 := range *m {
		keyTarget2, err := mapTarget1.StartKey()
		if err != nil {
			return err
		}
		if err := keyTarget2.FromBool(bool(key3), tt.NonOptional().Key()); err != nil {
			return err
		}
		valueTarget4, err := mapTarget1.FinishKeyStartField(keyTarget2)
		if err != nil {
			return err
		}
		if err := valueTarget4.FromString(string(value5), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := mapTarget1.FinishField(keyTarget2, valueTarget4); err != nil {
			return err
		}
	}
	if err := t.FinishMap(mapTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MapOnlyB) MakeVDLTarget() vdl.Target {
	return &MapOnlyBTarget{Value: m}
}

type MapOnlyBTarget struct {
	Value      *MapOnlyB
	currKey    bool
	currElem   string
	keyTarget  vdl.BoolTarget
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *MapOnlyBTarget) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*MapOnlyB)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(MapOnlyB)
	return t, nil
}
func (t *MapOnlyBTarget) StartKey() (key vdl.Target, _ error) {
	t.currKey = false
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *MapOnlyBTarget) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = ""
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *MapOnlyBTarget) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *MapOnlyBTarget) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type MapOnlyB2 map[NBool]NString

func (MapOnlyB2) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.MapOnlyB2"`
}) {
}

func (m *MapOnlyB2) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	mapTarget1, err := t.StartMap(tt, len((*m)))
	if err != nil {
		return err
	}
	for key3, value5 := range *m {
		keyTarget2, err := mapTarget1.StartKey()
		if err != nil {
			return err
		}

		if err := key3.FillVDLTarget(keyTarget2, tt.NonOptional().Key()); err != nil {
			return err
		}
		valueTarget4, err := mapTarget1.FinishKeyStartField(keyTarget2)
		if err != nil {
			return err
		}

		if err := value5.FillVDLTarget(valueTarget4, tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := mapTarget1.FinishField(keyTarget2, valueTarget4); err != nil {
			return err
		}
	}
	if err := t.FinishMap(mapTarget1); err != nil {
		return err
	}
	return nil
}

func (m *MapOnlyB2) MakeVDLTarget() vdl.Target {
	return &MapOnlyB2Target{Value: m}
}

type MapOnlyB2Target struct {
	Value      *MapOnlyB2
	currKey    NBool
	currElem   NString
	keyTarget  NBoolTarget
	elemTarget NStringTarget
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *MapOnlyB2Target) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*MapOnlyB2)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(MapOnlyB2)
	return t, nil
}
func (t *MapOnlyB2Target) StartKey() (key vdl.Target, _ error) {
	t.currKey = NBool(false)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *MapOnlyB2Target) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = NString("")
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *MapOnlyB2Target) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *MapOnlyB2Target) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

type (
	// BdeUnion represents any single field of the BdeUnion union type.
	BdeUnion interface {
		// Index returns the field index.
		Index() int
		// Interface returns the field value as an interface.
		Interface() interface{}
		// Name returns the field name.
		Name() string
		// __VDLReflect describes the BdeUnion union type.
		__VDLReflect(__BdeUnionReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
	}
	// BdeUnionB represents field B of the BdeUnion union type.
	BdeUnionB struct{ Value string }
	// BdeUnionD represents field D of the BdeUnion union type.
	BdeUnionD struct{ Value *vdl.Value }
	// BdeUnionE represents field E of the BdeUnion union type.
	BdeUnionE struct{ Value *vdl.Type }
	// __BdeUnionReflect describes the BdeUnion union type.
	__BdeUnionReflect struct {
		Name               string `vdl:"v.io/v23/vom/testdata/types.BdeUnion"`
		Type               BdeUnion
		UnionTargetFactory bdeUnionTargetFactory
		Union              struct {
			B BdeUnionB
			D BdeUnionD
			E BdeUnionE
		}
	}
)

func (x BdeUnionB) Index() int                     { return 0 }
func (x BdeUnionB) Interface() interface{}         { return x.Value }
func (x BdeUnionB) Name() string                   { return "B" }
func (x BdeUnionB) __VDLReflect(__BdeUnionReflect) {}

func (m BdeUnionB) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromString(string(m.Value), tt.NonOptional().Field(0).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m BdeUnionB) MakeVDLTarget() vdl.Target {
	return nil
}

func (x BdeUnionD) Index() int                     { return 1 }
func (x BdeUnionD) Interface() interface{}         { return x.Value }
func (x BdeUnionD) Name() string                   { return "D" }
func (x BdeUnionD) __VDLReflect(__BdeUnionReflect) {}

func (m BdeUnionD) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("D")
	if err != nil {
		return err
	}

	if m.Value == nil {
		if err := fieldTarget3.FromNil(tt.NonOptional().Field(1).Type); err != nil {
			return err
		}
	} else {
		if err := vdl.FromValue(fieldTarget3, m.Value); err != nil {
			return err
		}
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m BdeUnionD) MakeVDLTarget() vdl.Target {
	return nil
}

func (x BdeUnionE) Index() int                     { return 2 }
func (x BdeUnionE) Interface() interface{}         { return x.Value }
func (x BdeUnionE) Name() string                   { return "E" }
func (x BdeUnionE) __VDLReflect(__BdeUnionReflect) {}

func (m BdeUnionE) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("E")
	if err != nil {
		return err
	}
	typeObjectVal4 := m.Value
	if typeObjectVal4 == nil {
		typeObjectVal4 = vdl.AnyType
	}
	if err := fieldTarget3.FromTypeObject(typeObjectVal4); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m BdeUnionE) MakeVDLTarget() vdl.Target {
	return nil
}

type BdeUnionTarget struct {
	Value     *BdeUnion
	fieldName string
	anyValue  vdl.Value
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *BdeUnionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if ttWant := vdl.TypeOf((*BdeUnion)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}

	return t, nil
}
func (t *BdeUnionTarget) StartField(name string) (key, field vdl.Target, _ error) {
	t.fieldName = name
	switch name {
	case "B":
		val := ""
		return nil, &vdl.StringTarget{Value: &val}, nil
	case "D":
		t.anyValue = vdl.Value{}
		target, err := vdl.ValueTarget(&t.anyValue)
		return nil, target, err
	case "E":
		val := vdl.AnyType
		return nil, &vdl.TypeObjectTarget{Value: &val}, nil
	default:
		return nil, nil, fmt.Errorf("field %s not in union v.io/v23/vom/testdata/types.BdeUnion", name)
	}
}
func (t *BdeUnionTarget) FinishField(_, fieldTarget vdl.Target) error {
	switch t.fieldName {
	case "B":
		*t.Value = BdeUnionB{*(fieldTarget.(*vdl.StringTarget)).Value}
	case "D":
		*t.Value = BdeUnionD{&t.anyValue}
	case "E":
		*t.Value = BdeUnionE{*(fieldTarget.(*vdl.TypeObjectTarget)).Value}
	}
	return nil
}
func (t *BdeUnionTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type bdeUnionTargetFactory struct{}

func (t bdeUnionTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
	if typedUnion, ok := union.(*BdeUnion); ok {
		return &BdeUnionTarget{Value: typedUnion}, nil
	}
	return nil, fmt.Errorf("got %T, want *BdeUnion", union)
}

type BrieEnum int

const (
	BrieEnumGlee BrieEnum = iota
	BrieEnumBrie
	BrieEnumThree
)

// BrieEnumAll holds all labels for BrieEnum.
var BrieEnumAll = [...]BrieEnum{BrieEnumGlee, BrieEnumBrie, BrieEnumThree}

// BrieEnumFromString creates a BrieEnum from a string label.
func BrieEnumFromString(label string) (x BrieEnum, err error) {
	err = x.Set(label)
	return
}

// Set assigns label to x.
func (x *BrieEnum) Set(label string) error {
	switch label {
	case "Glee", "glee":
		*x = BrieEnumGlee
		return nil
	case "Brie", "brie":
		*x = BrieEnumBrie
		return nil
	case "Three", "three":
		*x = BrieEnumThree
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in types.BrieEnum", label)
}

// String returns the string label of x.
func (x BrieEnum) String() string {
	switch x {
	case BrieEnumGlee:
		return "Glee"
	case BrieEnumBrie:
		return "Brie"
	case BrieEnumThree:
		return "Three"
	}
	return ""
}

func (BrieEnum) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.BrieEnum"`
	Enum struct{ Glee, Brie, Three string }
}) {
}

func (m *BrieEnum) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), tt); err != nil {
		return err
	}
	return nil
}

func (m *BrieEnum) MakeVDLTarget() vdl.Target {
	return &BrieEnumTarget{Value: m}
}

type BrieEnumTarget struct {
	Value *BrieEnum
	vdl.TargetBase
}

func (t *BrieEnumTarget) FromEnumLabel(src string, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*BrieEnum)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	switch src {
	case "Glee":
		*t.Value = 0
	case "Brie":
		*t.Value = 1
	case "Three":
		*t.Value = 2
	default:
		return fmt.Errorf("label %s not in enum v.io/v23/vom/testdata/types.BrieEnum", src)
	}

	return nil
}

type BeanEnum int

const (
	BeanEnumBean BeanEnum = iota
)

// BeanEnumAll holds all labels for BeanEnum.
var BeanEnumAll = [...]BeanEnum{BeanEnumBean}

// BeanEnumFromString creates a BeanEnum from a string label.
func BeanEnumFromString(label string) (x BeanEnum, err error) {
	err = x.Set(label)
	return
}

// Set assigns label to x.
func (x *BeanEnum) Set(label string) error {
	switch label {
	case "Bean", "bean":
		*x = BeanEnumBean
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in types.BeanEnum", label)
}

// String returns the string label of x.
func (x BeanEnum) String() string {
	switch x {
	case BeanEnumBean:
		return "Bean"
	}
	return ""
}

func (BeanEnum) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.BeanEnum"`
	Enum struct{ Bean string }
}) {
}

func (m *BeanEnum) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), tt); err != nil {
		return err
	}
	return nil
}

func (m *BeanEnum) MakeVDLTarget() vdl.Target {
	return &BeanEnumTarget{Value: m}
}

type BeanEnumTarget struct {
	Value *BeanEnum
	vdl.TargetBase
}

func (t *BeanEnumTarget) FromEnumLabel(src string, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*BeanEnum)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	switch src {
	case "Bean":
		*t.Value = 0
	default:
		return fmt.Errorf("label %s not in enum v.io/v23/vom/testdata/types.BeanEnum", src)
	}

	return nil
}

type FoodEnum int

const (
	FoodEnumBean FoodEnum = iota
	FoodEnumBrie
	FoodEnumCherry
)

// FoodEnumAll holds all labels for FoodEnum.
var FoodEnumAll = [...]FoodEnum{FoodEnumBean, FoodEnumBrie, FoodEnumCherry}

// FoodEnumFromString creates a FoodEnum from a string label.
func FoodEnumFromString(label string) (x FoodEnum, err error) {
	err = x.Set(label)
	return
}

// Set assigns label to x.
func (x *FoodEnum) Set(label string) error {
	switch label {
	case "Bean", "bean":
		*x = FoodEnumBean
		return nil
	case "Brie", "brie":
		*x = FoodEnumBrie
		return nil
	case "Cherry", "cherry":
		*x = FoodEnumCherry
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in types.FoodEnum", label)
}

// String returns the string label of x.
func (x FoodEnum) String() string {
	switch x {
	case FoodEnumBean:
		return "Bean"
	case FoodEnumBrie:
		return "Brie"
	case FoodEnumCherry:
		return "Cherry"
	}
	return ""
}

func (FoodEnum) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.FoodEnum"`
	Enum struct{ Bean, Brie, Cherry string }
}) {
}

func (m *FoodEnum) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), tt); err != nil {
		return err
	}
	return nil
}

func (m *FoodEnum) MakeVDLTarget() vdl.Target {
	return &FoodEnumTarget{Value: m}
}

type FoodEnumTarget struct {
	Value *FoodEnum
	vdl.TargetBase
}

func (t *FoodEnumTarget) FromEnumLabel(src string, tt *vdl.Type) error {

	if ttWant := vdl.TypeOf((*FoodEnum)(nil)); !vdl.Compatible(tt, ttWant) {
		return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	switch src {
	case "Bean":
		*t.Value = 0
	case "Brie":
		*t.Value = 1
	case "Cherry":
		*t.Value = 2
	default:
		return fmt.Errorf("label %s not in enum v.io/v23/vom/testdata/types.FoodEnum", src)
	}

	return nil
}

type StructAny struct {
	Any *vdl.Value
}

func (StructAny) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.StructAny"`
}) {
}

func (m *StructAny) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Any")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.Any == nil {
			if err := fieldTarget3.FromNil(tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
		} else {
			if err := vdl.FromValue(fieldTarget3, m.Any); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *StructAny) MakeVDLTarget() vdl.Target {
	return &StructAnyTarget{Value: m}
}

type StructAnyTarget struct {
	Value *StructAny

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *StructAnyTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*StructAny)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *StructAnyTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Any":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Any))
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.StructAny", name)
	}
}
func (t *StructAnyTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *StructAnyTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type StructMap struct {
	Map map[int64]int64
}

func (StructMap) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.StructMap"`
}) {
}

func (m *StructMap) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Map")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.Map))
		if err != nil {
			return err
		}
		for key6, value8 := range m.Map {
			keyTarget5, err := mapTarget4.StartKey()
			if err != nil {
				return err
			}
			if err := keyTarget5.FromInt(int64(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
				return err
			}
			valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5)
			if err != nil {
				return err
			}
			if err := valueTarget7.FromInt(int64(value8), tt.NonOptional().Field(0).Type.Elem()); err != nil {
				return err
			}
			if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil {
				return err
			}
		}
		if err := fieldTarget3.FinishMap(mapTarget4); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *StructMap) MakeVDLTarget() vdl.Target {
	return &StructMapTarget{Value: m}
}

type StructMapTarget struct {
	Value     *StructMap
	mapTarget __VDLTarget12_map
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *StructMapTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*StructMap)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *StructMapTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Map":
		t.mapTarget.Value = &t.Value.Map
		target, err := &t.mapTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.StructMap", name)
	}
}
func (t *StructMapTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *StructMapTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// map[int64]int64
type __VDLTarget12_map struct {
	Value      *map[int64]int64
	currKey    int64
	currElem   int64
	keyTarget  vdl.Int64Target
	elemTarget vdl.Int64Target
	vdl.TargetBase
	vdl.MapTargetBase
}

func (t *__VDLTarget12_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {

	if ttWant := vdl.TypeOf((*map[int64]int64)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	*t.Value = make(map[int64]int64)
	return t, nil
}
func (t *__VDLTarget12_map) StartKey() (key vdl.Target, _ error) {
	t.currKey = int64(0)
	t.keyTarget.Value = &t.currKey
	target, err := &t.keyTarget, error(nil)
	return target, err
}
func (t *__VDLTarget12_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
	t.currElem = int64(0)
	t.elemTarget.Value = &t.currElem
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget12_map) FinishField(key, field vdl.Target) error {
	(*t.Value)[t.currKey] = t.currElem
	return nil
}
func (t *__VDLTarget12_map) FinishMap(elem vdl.MapTarget) error {
	if len(*t.Value) == 0 {
		*t.Value = nil
	}

	return nil
}

// Since the encoding changes if struct fields are zero values,
// test each of the kinds in a struct both as zero and non-zero values.
type StructManyTypes struct {
	Bool             bool
	AByte            byte
	Int16            int16
	Int32            int32
	Int64            int64
	Uint16           uint16
	Uint32           uint32
	Uint64           uint64
	String           string
	Bytes            []byte
	Float32          float32
	Float64          float64
	FoodEnum         FoodEnum
	NEnum            NEnum
	NListUint64      NListUint64
	NByteArray       NByteArray
	NArray2Uint64    NArray2Uint64
	NSetUint64       NSetUint64
	NMapUint64String NMapUint64String
	NStruct          NStruct
	NUnion           NUnion
	TypeObject       *vdl.Type
}

func (StructManyTypes) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.StructManyTypes"`
}) {
}

func (m *StructManyTypes) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Bool")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromBool(bool(m.Bool), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("AByte")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromUint(uint64(m.AByte), tt.NonOptional().Field(1).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Int16")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget7.FromInt(int64(m.Int16), tt.NonOptional().Field(2).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Int32")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget9.FromInt(int64(m.Int32), tt.NonOptional().Field(3).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
			return err
		}
	}
	keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("Int64")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget11.FromInt(int64(m.Int64), tt.NonOptional().Field(4).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
			return err
		}
	}
	keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Uint16")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget13.FromUint(uint64(m.Uint16), tt.NonOptional().Field(5).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
			return err
		}
	}
	keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Uint32")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget15.FromUint(uint64(m.Uint32), tt.NonOptional().Field(6).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
			return err
		}
	}
	keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("Uint64")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget17.FromUint(uint64(m.Uint64), tt.NonOptional().Field(7).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
			return err
		}
	}
	keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("String")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget19.FromString(string(m.String), tt.NonOptional().Field(8).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
			return err
		}
	}
	keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("Bytes")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := fieldTarget21.FromBytes([]byte(m.Bytes), tt.NonOptional().Field(9).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
			return err
		}
	}
	keyTarget22, fieldTarget23, err := fieldsTarget1.StartField("Float32")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget23.FromFloat(float64(m.Float32), tt.NonOptional().Field(10).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget22, fieldTarget23); err != nil {
			return err
		}
	}
	keyTarget24, fieldTarget25, err := fieldsTarget1.StartField("Float64")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget25.FromFloat(float64(m.Float64), tt.NonOptional().Field(11).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget24, fieldTarget25); err != nil {
			return err
		}
	}
	keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("FoodEnum")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.FoodEnum.FillVDLTarget(fieldTarget27, tt.NonOptional().Field(12).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
			return err
		}
	}
	keyTarget28, fieldTarget29, err := fieldsTarget1.StartField("NEnum")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.NEnum.FillVDLTarget(fieldTarget29, tt.NonOptional().Field(13).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget28, fieldTarget29); err != nil {
			return err
		}
	}
	keyTarget30, fieldTarget31, err := fieldsTarget1.StartField("NListUint64")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.NListUint64.FillVDLTarget(fieldTarget31, tt.NonOptional().Field(14).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget30, fieldTarget31); err != nil {
			return err
		}
	}
	keyTarget32, fieldTarget33, err := fieldsTarget1.StartField("NByteArray")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.NByteArray.FillVDLTarget(fieldTarget33, tt.NonOptional().Field(15).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget32, fieldTarget33); err != nil {
			return err
		}
	}
	keyTarget34, fieldTarget35, err := fieldsTarget1.StartField("NArray2Uint64")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.NArray2Uint64.FillVDLTarget(fieldTarget35, tt.NonOptional().Field(16).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget34, fieldTarget35); err != nil {
			return err
		}
	}
	keyTarget36, fieldTarget37, err := fieldsTarget1.StartField("NSetUint64")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.NSetUint64.FillVDLTarget(fieldTarget37, tt.NonOptional().Field(17).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget36, fieldTarget37); err != nil {
			return err
		}
	}
	keyTarget38, fieldTarget39, err := fieldsTarget1.StartField("NMapUint64String")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.NMapUint64String.FillVDLTarget(fieldTarget39, tt.NonOptional().Field(18).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget38, fieldTarget39); err != nil {
			return err
		}
	}
	keyTarget40, fieldTarget41, err := fieldsTarget1.StartField("NStruct")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.NStruct.FillVDLTarget(fieldTarget41, tt.NonOptional().Field(19).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget40, fieldTarget41); err != nil {
			return err
		}
	}
	keyTarget42, fieldTarget43, err := fieldsTarget1.StartField("NUnion")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		unionValue44 := m.NUnion
		if unionValue44 == nil {
			unionValue44 = NUnionA{}
		}
		if err := unionValue44.FillVDLTarget(fieldTarget43, tt.NonOptional().Field(20).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget42, fieldTarget43); err != nil {
			return err
		}
	}
	keyTarget45, fieldTarget46, err := fieldsTarget1.StartField("TypeObject")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		typeObjectVal47 := m.TypeObject
		if typeObjectVal47 == nil {
			typeObjectVal47 = vdl.AnyType
		}
		if err := fieldTarget46.FromTypeObject(typeObjectVal47); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget45, fieldTarget46); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *StructManyTypes) MakeVDLTarget() vdl.Target {
	return &StructManyTypesTarget{Value: m}
}

type StructManyTypesTarget struct {
	Value                  *StructManyTypes
	boolTarget             vdl.BoolTarget
	aByteTarget            vdl.ByteTarget
	int16Target            vdl.Int16Target
	int32Target            vdl.Int32Target
	int64Target            vdl.Int64Target
	uint16Target           vdl.Uint16Target
	uint32Target           vdl.Uint32Target
	uint64Target           vdl.Uint64Target
	stringTarget           vdl.StringTarget
	bytesTarget            vdl.BytesTarget
	float32Target          vdl.Float32Target
	float64Target          vdl.Float64Target
	foodEnumTarget         FoodEnumTarget
	nEnumTarget            NEnumTarget
	nListUint64Target      NListUint64Target
	nByteArrayTarget       NByteArrayTarget
	nArray2Uint64Target    NArray2Uint64Target
	nSetUint64Target       NSetUint64Target
	nMapUint64StringTarget NMapUint64StringTarget
	nStructTarget          NStructTarget
	nUnionTarget           NUnionTarget
	typeObjectTarget       vdl.TypeObjectTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *StructManyTypesTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*StructManyTypes)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *StructManyTypesTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Bool":
		t.boolTarget.Value = &t.Value.Bool
		target, err := &t.boolTarget, error(nil)
		return nil, target, err
	case "AByte":
		t.aByteTarget.Value = &t.Value.AByte
		target, err := &t.aByteTarget, error(nil)
		return nil, target, err
	case "Int16":
		t.int16Target.Value = &t.Value.Int16
		target, err := &t.int16Target, error(nil)
		return nil, target, err
	case "Int32":
		t.int32Target.Value = &t.Value.Int32
		target, err := &t.int32Target, error(nil)
		return nil, target, err
	case "Int64":
		t.int64Target.Value = &t.Value.Int64
		target, err := &t.int64Target, error(nil)
		return nil, target, err
	case "Uint16":
		t.uint16Target.Value = &t.Value.Uint16
		target, err := &t.uint16Target, error(nil)
		return nil, target, err
	case "Uint32":
		t.uint32Target.Value = &t.Value.Uint32
		target, err := &t.uint32Target, error(nil)
		return nil, target, err
	case "Uint64":
		t.uint64Target.Value = &t.Value.Uint64
		target, err := &t.uint64Target, error(nil)
		return nil, target, err
	case "String":
		t.stringTarget.Value = &t.Value.String
		target, err := &t.stringTarget, error(nil)
		return nil, target, err
	case "Bytes":
		t.bytesTarget.Value = &t.Value.Bytes
		target, err := &t.bytesTarget, error(nil)
		return nil, target, err
	case "Float32":
		t.float32Target.Value = &t.Value.Float32
		target, err := &t.float32Target, error(nil)
		return nil, target, err
	case "Float64":
		t.float64Target.Value = &t.Value.Float64
		target, err := &t.float64Target, error(nil)
		return nil, target, err
	case "FoodEnum":
		t.foodEnumTarget.Value = &t.Value.FoodEnum
		target, err := &t.foodEnumTarget, error(nil)
		return nil, target, err
	case "NEnum":
		t.nEnumTarget.Value = &t.Value.NEnum
		target, err := &t.nEnumTarget, error(nil)
		return nil, target, err
	case "NListUint64":
		t.nListUint64Target.Value = &t.Value.NListUint64
		target, err := &t.nListUint64Target, error(nil)
		return nil, target, err
	case "NByteArray":
		t.nByteArrayTarget.Value = &t.Value.NByteArray
		target, err := &t.nByteArrayTarget, error(nil)
		return nil, target, err
	case "NArray2Uint64":
		t.nArray2Uint64Target.Value = &t.Value.NArray2Uint64
		target, err := &t.nArray2Uint64Target, error(nil)
		return nil, target, err
	case "NSetUint64":
		t.nSetUint64Target.Value = &t.Value.NSetUint64
		target, err := &t.nSetUint64Target, error(nil)
		return nil, target, err
	case "NMapUint64String":
		t.nMapUint64StringTarget.Value = &t.Value.NMapUint64String
		target, err := &t.nMapUint64StringTarget, error(nil)
		return nil, target, err
	case "NStruct":
		t.nStructTarget.Value = &t.Value.NStruct
		target, err := &t.nStructTarget, error(nil)
		return nil, target, err
	case "NUnion":
		t.nUnionTarget.Value = &t.Value.NUnion
		target, err := &t.nUnionTarget, error(nil)
		return nil, target, err
	case "TypeObject":
		t.typeObjectTarget.Value = &t.Value.TypeObject
		target, err := &t.typeObjectTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.StructManyTypes", name)
	}
}
func (t *StructManyTypesTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *StructManyTypesTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type AnySlice []*vdl.Value

func (AnySlice) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.AnySlice"`
}) {
}

func (m *AnySlice) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, len((*m)))
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}

		if elem3 == nil {
			if err := elemTarget2.FromNil(tt.NonOptional().Elem()); err != nil {
				return err
			}
		} else {
			if err := vdl.FromValue(elemTarget2, elem3); err != nil {
				return err
			}
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *AnySlice) MakeVDLTarget() vdl.Target {
	return &AnySliceTarget{Value: m}
}

// AnySlice
type AnySliceTarget struct {
	Value *AnySlice

	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *AnySliceTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*AnySlice)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make(AnySlice, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *AnySliceTarget) StartElem(index int) (elem vdl.Target, _ error) {
	target, err := vdl.ReflectTarget(reflect.ValueOf(&(*t.Value)[index]))
	return target, err
}
func (t *AnySliceTarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *AnySliceTarget) FinishList(elem vdl.ListTarget) error {

	return nil
}

type LargeMessageType struct {
	Payload []byte
	Next    *LargeMessageType
}

func (LargeMessageType) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.LargeMessageType"`
}) {
}

func (m *LargeMessageType) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Payload")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := fieldTarget3.FromBytes([]byte(m.Payload), tt.NonOptional().Field(0).Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Next")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.Next == nil {
			if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		} else {
			if err := m.Next.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *LargeMessageType) MakeVDLTarget() vdl.Target {
	return &LargeMessageTypeTarget{Value: m}
}

type LargeMessageTypeTarget struct {
	Value         *LargeMessageType
	payloadTarget vdl.BytesTarget

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *LargeMessageTypeTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*LargeMessageType)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *LargeMessageTypeTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Payload":
		t.payloadTarget.Value = &t.Value.Payload
		target, err := &t.payloadTarget, error(nil)
		return nil, target, err
	case "Next":
		target, err := &__VDLTarget13_optional{Value: &t.Value.Next}, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.LargeMessageType", name)
	}
}
func (t *LargeMessageTypeTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *LargeMessageTypeTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// Optional LargeMessageType
type __VDLTarget13_optional struct {
	Value **LargeMessageType

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *__VDLTarget13_optional) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if *t.Value == nil {
		*t.Value = &LargeMessageType{}
	}
	target, err := &LargeMessageTypeTarget{Value: *t.Value}, error(nil)
	if err != nil {
		return nil, err
	}
	return target.StartFields(tt)
}
func (t *__VDLTarget13_optional) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *__VDLTarget13_optional) FromNil(tt *vdl.Type) error {

	*t.Value = nil

	return nil
}

type LargeAnyMessageType struct {
	Payload *vdl.Value
	Next    *LargeAnyMessageType
}

func (LargeAnyMessageType) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/testdata/types.LargeAnyMessageType"`
}) {
}

func (m *LargeAnyMessageType) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Payload")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.Payload == nil {
			if err := fieldTarget3.FromNil(tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
		} else {
			if err := vdl.FromValue(fieldTarget3, m.Payload); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Next")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.Next == nil {
			if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		} else {
			if err := m.Next.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *LargeAnyMessageType) MakeVDLTarget() vdl.Target {
	return &LargeAnyMessageTypeTarget{Value: m}
}

type LargeAnyMessageTypeTarget struct {
	Value *LargeAnyMessageType

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *LargeAnyMessageTypeTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*LargeAnyMessageType)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *LargeAnyMessageTypeTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Payload":
		target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Payload))
		return nil, target, err
	case "Next":
		target, err := &__VDLTarget14_optional{Value: &t.Value.Next}, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/vom/testdata/types.LargeAnyMessageType", name)
	}
}
func (t *LargeAnyMessageTypeTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *LargeAnyMessageTypeTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// Optional LargeAnyMessageType
type __VDLTarget14_optional struct {
	Value **LargeAnyMessageType

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *__VDLTarget14_optional) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if *t.Value == nil {
		*t.Value = &LargeAnyMessageType{}
	}
	target, err := &LargeAnyMessageTypeTarget{Value: *t.Value}, error(nil)
	if err != nil {
		return nil, err
	}
	return target.StartFields(tt)
}
func (t *__VDLTarget14_optional) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *__VDLTarget14_optional) FromNil(tt *vdl.Type) error {

	*t.Value = nil

	return nil
}

// Create zero values for each type.
var (
	__VDLZeroTestCase     = TestCase{}
	__VDLZeroConvertGroup = ConvertGroup{
		PrimaryType: vdl.AnyType,
	}
	__VDLZeroVomdataStruct    = VomdataStruct{}
	__VDLZeroNBool            = NBool(false)
	__VDLZeroNString          = NString("")
	__VDLZeroNByteSlice       = NByteSlice(nil)
	__VDLZeroNByteArray       = NByteArray{}
	__VDLZeroNByte            = NByte(0)
	__VDLZeroNUint16          = NUint16(0)
	__VDLZeroNUint32          = NUint32(0)
	__VDLZeroNUint64          = NUint64(0)
	__VDLZeroNInt8            = NInt8(0)
	__VDLZeroNInt16           = NInt16(0)
	__VDLZeroNInt32           = NInt32(0)
	__VDLZeroNInt64           = NInt64(0)
	__VDLZeroNFloat32         = NFloat32(0)
	__VDLZeroNFloat64         = NFloat64(0)
	__VDLZeroNArray2Uint64    = NArray2Uint64{}
	__VDLZeroNListUint64      = NListUint64(nil)
	__VDLZeroNSetUint64       = NSetUint64(nil)
	__VDLZeroNMapUint64String = NMapUint64String(nil)
	__VDLZeroNStruct          = NStruct{}
	__VDLZeroNEnum            = NEnumA
	__VDLZeroNUnion           = NUnion(NUnionA{})
	__VDLZeroMBool            = MBool(false)
	__VDLZeroMStruct          = MStruct{
		E: vdl.AnyType,
	}
	__VDLZeroMList        = MList(nil)
	__VDLZeroMMap         = MMap(nil)
	__VDLZeroMByteSlice   = MByteSlice(nil)
	__VDLZeroMInt8Slice   = MInt8Slice(nil)
	__VDLZeroRecA         = RecA(nil)
	__VDLZeroRecY         = RecY(nil)
	__VDLZeroRecX         = RecX(nil)
	__VDLZeroRec4         = Rec4(nil)
	__VDLZeroRec3         = Rec3(nil)
	__VDLZeroRec2         = Rec2(nil)
	__VDLZeroRec1         = Rec1(nil)
	__VDLZeroRecStruct    = RecStruct{}
	__VDLZeroRec1234      = Rec1234{}
	__VDLZeroRec1234A     = Rec1234A{}
	__VDLZeroRec1234B     = Rec1234B{}
	__VDLZeroRec1234All   = Rec1234All{}
	__VDLZeroListString   = ListString(nil)
	__VDLZeroArray3String = Array3String{}
	__VDLZeroArray4String = Array4String{}
	__VDLZeroAbcStruct    = AbcStruct{}
	__VDLZeroAdeStruct    = AdeStruct{
		E: vdl.AnyType,
	}
	__VDLZeroXyzStruct       = XyzStruct{}
	__VDLZeroYzStruct        = YzStruct{}
	__VDLZeroZStruct         = ZStruct{}
	__VDLZeroMapOnlyStruct   = MapOnlyStruct{}
	__VDLZeroStructOnlyMap   = StructOnlyMap(nil)
	__VDLZeroMapSetStruct    = MapSetStruct{}
	__VDLZeroSetStructMap    = SetStructMap(nil)
	__VDLZeroMapStructSet    = MapStructSet(nil)
	__VDLZeroSetOnlyMap      = SetOnlyMap(nil)
	__VDLZeroSometimesSetMap = SometimesSetMap(nil)
	__VDLZeroMapOnlySet      = MapOnlySet(nil)
	__VDLZeroSetOnlyA        = SetOnlyA(nil)
	__VDLZeroSetOnlyA2       = SetOnlyA2(nil)
	__VDLZeroSetOnlyB        = SetOnlyB(nil)
	__VDLZeroSetOnlyB2       = SetOnlyB2(nil)
	__VDLZeroMapOnlyA        = MapOnlyA(nil)
	__VDLZeroMapOnlyA2       = MapOnlyA2(nil)
	__VDLZeroMapOnlyB        = MapOnlyB(nil)
	__VDLZeroMapOnlyB2       = MapOnlyB2(nil)
	__VDLZeroBdeUnion        = BdeUnion(BdeUnionB{})
	__VDLZeroBrieEnum        = BrieEnumGlee
	__VDLZeroBeanEnum        = BeanEnumBean
	__VDLZeroFoodEnum        = FoodEnumBean
	__VDLZeroStructAny       = StructAny{}
	__VDLZeroStructMap       = StructMap{}
	__VDLZeroStructManyTypes = StructManyTypes{
		NUnion:     NUnionA{},
		TypeObject: vdl.AnyType,
	}
	__VDLZeroAnySlice            = AnySlice(nil)
	__VDLZeroLargeMessageType    = LargeMessageType{}
	__VDLZeroLargeAnyMessageType = LargeAnyMessageType{}
)

var __VDLInitCalled bool

// __VDLInit performs vdl initialization.  It is safe to call multiple times.
// If you have an init ordering issue, just insert the following line verbatim
// into your source files in this package, right after the "package foo" clause:
//
//    var _ = __VDLInit()
//
// The purpose of this function is to ensure that vdl initialization occurs in
// the right order, and very early in the init sequence.  In particular, vdl
// registration and package variable initialization needs to occur before
// functions like vdl.TypeOf will work properly.
//
// This function returns a dummy value, so that it can be used to initialize the
// first var in the file, to take advantage of Go's defined init order.
func __VDLInit() struct{} {
	if __VDLInitCalled {
		return struct{}{}
	}

	// Register types.
	vdl.Register((*TestCase)(nil))
	vdl.Register((*ConvertGroup)(nil))
	vdl.Register((*VomdataStruct)(nil))
	vdl.Register((*NBool)(nil))
	vdl.Register((*NString)(nil))
	vdl.Register((*NByteSlice)(nil))
	vdl.Register((*NByteArray)(nil))
	vdl.Register((*NByte)(nil))
	vdl.Register((*NUint16)(nil))
	vdl.Register((*NUint32)(nil))
	vdl.Register((*NUint64)(nil))
	vdl.Register((*NInt8)(nil))
	vdl.Register((*NInt16)(nil))
	vdl.Register((*NInt32)(nil))
	vdl.Register((*NInt64)(nil))
	vdl.Register((*NFloat32)(nil))
	vdl.Register((*NFloat64)(nil))
	vdl.Register((*NArray2Uint64)(nil))
	vdl.Register((*NListUint64)(nil))
	vdl.Register((*NSetUint64)(nil))
	vdl.Register((*NMapUint64String)(nil))
	vdl.Register((*NStruct)(nil))
	vdl.Register((*NEnum)(nil))
	vdl.Register((*NUnion)(nil))
	vdl.Register((*MBool)(nil))
	vdl.Register((*MStruct)(nil))
	vdl.Register((*MList)(nil))
	vdl.Register((*MMap)(nil))
	vdl.Register((*MByteSlice)(nil))
	vdl.Register((*MInt8Slice)(nil))
	vdl.Register((*RecA)(nil))
	vdl.Register((*RecY)(nil))
	vdl.Register((*RecX)(nil))
	vdl.Register((*Rec4)(nil))
	vdl.Register((*Rec3)(nil))
	vdl.Register((*Rec2)(nil))
	vdl.Register((*Rec1)(nil))
	vdl.Register((*RecStruct)(nil))
	vdl.Register((*Rec1234)(nil))
	vdl.Register((*Rec1234A)(nil))
	vdl.Register((*Rec1234B)(nil))
	vdl.Register((*Rec1234All)(nil))
	vdl.Register((*ListString)(nil))
	vdl.Register((*Array3String)(nil))
	vdl.Register((*Array4String)(nil))
	vdl.Register((*AbcStruct)(nil))
	vdl.Register((*AdeStruct)(nil))
	vdl.Register((*XyzStruct)(nil))
	vdl.Register((*YzStruct)(nil))
	vdl.Register((*ZStruct)(nil))
	vdl.Register((*MapOnlyStruct)(nil))
	vdl.Register((*StructOnlyMap)(nil))
	vdl.Register((*MapSetStruct)(nil))
	vdl.Register((*SetStructMap)(nil))
	vdl.Register((*MapStructSet)(nil))
	vdl.Register((*SetOnlyMap)(nil))
	vdl.Register((*SometimesSetMap)(nil))
	vdl.Register((*MapOnlySet)(nil))
	vdl.Register((*SetOnlyA)(nil))
	vdl.Register((*SetOnlyA2)(nil))
	vdl.Register((*SetOnlyB)(nil))
	vdl.Register((*SetOnlyB2)(nil))
	vdl.Register((*MapOnlyA)(nil))
	vdl.Register((*MapOnlyA2)(nil))
	vdl.Register((*MapOnlyB)(nil))
	vdl.Register((*MapOnlyB2)(nil))
	vdl.Register((*BdeUnion)(nil))
	vdl.Register((*BrieEnum)(nil))
	vdl.Register((*BeanEnum)(nil))
	vdl.Register((*FoodEnum)(nil))
	vdl.Register((*StructAny)(nil))
	vdl.Register((*StructMap)(nil))
	vdl.Register((*StructManyTypes)(nil))
	vdl.Register((*AnySlice)(nil))
	vdl.Register((*LargeMessageType)(nil))
	vdl.Register((*LargeAnyMessageType)(nil))

	return struct{}{}
}