vom/wiretype.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.
// Source: wiretype.vdl

package vom

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

// typeId uniquely identifies a type definition within a vom stream.
type typeId uint64

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

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

func (m *typeId) MakeVDLTarget() vdl.Target {
	return &typeIdTarget{Value: m}
}

type typeIdTarget struct {
	Value *typeId
	vdl.TargetBase
}

func (t *typeIdTarget) FromUint(src uint64, tt *vdl.Type) error {
	*t.Value = typeId(src)

	return nil
}
func (t *typeIdTarget) FromInt(src int64, tt *vdl.Type) error {
	val, err := vdlconv.Int64ToUint64(src)
	if err != nil {
		return err
	}
	*t.Value = typeId(val)

	return nil
}
func (t *typeIdTarget) FromFloat(src float64, tt *vdl.Type) error {
	val, err := vdlconv.Float64ToUint64(src)
	if err != nil {
		return err
	}
	*t.Value = typeId(val)

	return nil
}
func (t *typeIdTarget) FromComplex(src complex128, tt *vdl.Type) error {
	val, err := vdlconv.Complex128ToUint64(src)
	if err != nil {
		return err
	}
	*t.Value = typeId(val)

	return nil
}

type (
	// wireType represents any single field of the wireType union type.
	//
	// The wireType union is used to encode the payload part of each type message,
	// using the regular rules for encoding union values.  But unlike our regular
	// encoding, the type message for wireType itself (and its fields) are never
	// encoded; we need to bootstrap the system.  Thus unlike regular values, the
	// ordering of fields within the wire* types cannot be changed.
	wireType 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 wireType union type.
		__VDLReflect(__wireTypeReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
	}
	// wireTypeNamedT represents field NamedT of the wireType union type.
	//
	// FIELD INDICES MUST NOT BE CHANGED.
	wireTypeNamedT struct{ Value wireNamed } // INDEX = 0
	// wireTypeEnumT represents field EnumT of the wireType union type.
	wireTypeEnumT struct{ Value wireEnum } // INDEX = 1
	// wireTypeArrayT represents field ArrayT of the wireType union type.
	wireTypeArrayT struct{ Value wireArray } // INDEX = 2
	// wireTypeListT represents field ListT of the wireType union type.
	wireTypeListT struct{ Value wireList } // INDEX = 3
	// wireTypeSetT represents field SetT of the wireType union type.
	wireTypeSetT struct{ Value wireSet } // INDEX = 4
	// wireTypeMapT represents field MapT of the wireType union type.
	wireTypeMapT struct{ Value wireMap } // INDEX = 5
	// wireTypeStructT represents field StructT of the wireType union type.
	wireTypeStructT struct{ Value wireStruct } // INDEX = 6
	// wireTypeUnionT represents field UnionT of the wireType union type.
	wireTypeUnionT struct{ Value wireUnion } // INDEX = 7
	// wireTypeOptionalT represents field OptionalT of the wireType union type.
	wireTypeOptionalT struct{ Value wireOptional } // INDEX = 8
	// __wireTypeReflect describes the wireType union type.
	__wireTypeReflect struct {
		Name  string `vdl:"v.io/v23/vom.wireType"`
		Type  wireType
		Union struct {
			NamedT    wireTypeNamedT
			EnumT     wireTypeEnumT
			ArrayT    wireTypeArrayT
			ListT     wireTypeListT
			SetT      wireTypeSetT
			MapT      wireTypeMapT
			StructT   wireTypeStructT
			UnionT    wireTypeUnionT
			OptionalT wireTypeOptionalT
		}
	}
)

func (x wireTypeNamedT) Index() int                     { return 0 }
func (x wireTypeNamedT) Interface() interface{}         { return x.Value }
func (x wireTypeNamedT) Name() string                   { return "NamedT" }
func (x wireTypeNamedT) __VDLReflect(__wireTypeReflect) {}

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

	if err := m.Value.FillVDLTarget(fieldTarget3, __VDLType_wiretype_v_io_v23_vom_wireNamed); 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 wireTypeNamedT) MakeVDLTarget() vdl.Target {
	return nil
}

func (x wireTypeEnumT) Index() int                     { return 1 }
func (x wireTypeEnumT) Interface() interface{}         { return x.Value }
func (x wireTypeEnumT) Name() string                   { return "EnumT" }
func (x wireTypeEnumT) __VDLReflect(__wireTypeReflect) {}

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

	if err := m.Value.FillVDLTarget(fieldTarget3, __VDLType_wiretype_v_io_v23_vom_wireEnum); 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 wireTypeEnumT) MakeVDLTarget() vdl.Target {
	return nil
}

func (x wireTypeArrayT) Index() int                     { return 2 }
func (x wireTypeArrayT) Interface() interface{}         { return x.Value }
func (x wireTypeArrayT) Name() string                   { return "ArrayT" }
func (x wireTypeArrayT) __VDLReflect(__wireTypeReflect) {}

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

	if err := m.Value.FillVDLTarget(fieldTarget3, __VDLType_wiretype_v_io_v23_vom_wireArray); 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 wireTypeArrayT) MakeVDLTarget() vdl.Target {
	return nil
}

func (x wireTypeListT) Index() int                     { return 3 }
func (x wireTypeListT) Interface() interface{}         { return x.Value }
func (x wireTypeListT) Name() string                   { return "ListT" }
func (x wireTypeListT) __VDLReflect(__wireTypeReflect) {}

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

	if err := m.Value.FillVDLTarget(fieldTarget3, __VDLType_wiretype_v_io_v23_vom_wireList); 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 wireTypeListT) MakeVDLTarget() vdl.Target {
	return nil
}

func (x wireTypeSetT) Index() int                     { return 4 }
func (x wireTypeSetT) Interface() interface{}         { return x.Value }
func (x wireTypeSetT) Name() string                   { return "SetT" }
func (x wireTypeSetT) __VDLReflect(__wireTypeReflect) {}

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

	if err := m.Value.FillVDLTarget(fieldTarget3, __VDLType_wiretype_v_io_v23_vom_wireSet); 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 wireTypeSetT) MakeVDLTarget() vdl.Target {
	return nil
}

func (x wireTypeMapT) Index() int                     { return 5 }
func (x wireTypeMapT) Interface() interface{}         { return x.Value }
func (x wireTypeMapT) Name() string                   { return "MapT" }
func (x wireTypeMapT) __VDLReflect(__wireTypeReflect) {}

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

	if err := m.Value.FillVDLTarget(fieldTarget3, __VDLType_wiretype_v_io_v23_vom_wireMap); 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 wireTypeMapT) MakeVDLTarget() vdl.Target {
	return nil
}

func (x wireTypeStructT) Index() int                     { return 6 }
func (x wireTypeStructT) Interface() interface{}         { return x.Value }
func (x wireTypeStructT) Name() string                   { return "StructT" }
func (x wireTypeStructT) __VDLReflect(__wireTypeReflect) {}

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

	if err := m.Value.FillVDLTarget(fieldTarget3, __VDLType_wiretype_v_io_v23_vom_wireStruct); 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 wireTypeStructT) MakeVDLTarget() vdl.Target {
	return nil
}

func (x wireTypeUnionT) Index() int                     { return 7 }
func (x wireTypeUnionT) Interface() interface{}         { return x.Value }
func (x wireTypeUnionT) Name() string                   { return "UnionT" }
func (x wireTypeUnionT) __VDLReflect(__wireTypeReflect) {}

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

	if err := m.Value.FillVDLTarget(fieldTarget3, __VDLType_wiretype_v_io_v23_vom_wireUnion); 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 wireTypeUnionT) MakeVDLTarget() vdl.Target {
	return nil
}

func (x wireTypeOptionalT) Index() int                     { return 8 }
func (x wireTypeOptionalT) Interface() interface{}         { return x.Value }
func (x wireTypeOptionalT) Name() string                   { return "OptionalT" }
func (x wireTypeOptionalT) __VDLReflect(__wireTypeReflect) {}

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

	if err := m.Value.FillVDLTarget(fieldTarget3, __VDLType_wiretype_v_io_v23_vom_wireOptional); 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 wireTypeOptionalT) MakeVDLTarget() vdl.Target {
	return nil
}

// wireNamed represents a type definition for named primitives.
type wireNamed struct {
	Name string
	Base typeId
}

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

func (m *wireNamed) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_wiretype_v_io_v23_vom_wireNamed == nil || __VDLTypewiretype0 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	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), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Base")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Base.FillVDLTarget(fieldTarget5, __VDLType_wiretype_v_io_v23_vom_typeId); 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 *wireNamed) MakeVDLTarget() vdl.Target {
	return &wireNamedTarget{Value: m}
}

type wireNamedTarget struct {
	Value *wireNamed
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *wireNamedTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_wiretype_v_io_v23_vom_wireNamed) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_wiretype_v_io_v23_vom_wireNamed)
	}
	return t, nil
}
func (t *wireNamedTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		val, err := &vdl.StringTarget{Value: &t.Value.Name}, error(nil)
		return nil, val, err
	case "Base":
		val, err := &typeIdTarget{Value: &t.Value.Base}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_wiretype_v_io_v23_vom_wireNamed)
	}
}
func (t *wireNamedTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *wireNamedTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// wireEnum represents an type definition for enum types.
type wireEnum struct {
	Name   string
	Labels []string
}

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

func (m *wireEnum) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_wiretype_v_io_v23_vom_wireEnum == nil || __VDLTypewiretype1 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	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), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Labels")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		listTarget6, err := fieldTarget5.StartList(__VDLTypewiretype2, len(m.Labels))
		if err != nil {
			return err
		}
		for i, elem8 := range m.Labels {
			elemTarget7, err := listTarget6.StartElem(i)
			if err != nil {
				return err
			}
			if err := elemTarget7.FromString(string(elem8), vdl.StringType); err != nil {
				return err
			}
			if err := listTarget6.FinishElem(elemTarget7); err != nil {
				return err
			}
		}
		if err := fieldTarget5.FinishList(listTarget6); 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 *wireEnum) MakeVDLTarget() vdl.Target {
	return &wireEnumTarget{Value: m}
}

type wireEnumTarget struct {
	Value *wireEnum
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *wireEnumTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_wiretype_v_io_v23_vom_wireEnum) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_wiretype_v_io_v23_vom_wireEnum)
	}
	return t, nil
}
func (t *wireEnumTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		val, err := &vdl.StringTarget{Value: &t.Value.Name}, error(nil)
		return nil, val, err
	case "Labels":
		val, err := &vdl.StringSliceTarget{Value: &t.Value.Labels}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_wiretype_v_io_v23_vom_wireEnum)
	}
}
func (t *wireEnumTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *wireEnumTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// wireArray represents an type definition for array types.
type wireArray struct {
	Name string
	Elem typeId
	Len  uint64
}

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

func (m *wireArray) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_wiretype_v_io_v23_vom_wireArray == nil || __VDLTypewiretype3 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	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), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Elem")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Elem.FillVDLTarget(fieldTarget5, __VDLType_wiretype_v_io_v23_vom_typeId); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Len")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget7.FromUint(uint64(m.Len), vdl.Uint64Type); 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 *wireArray) MakeVDLTarget() vdl.Target {
	return &wireArrayTarget{Value: m}
}

type wireArrayTarget struct {
	Value *wireArray
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *wireArrayTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_wiretype_v_io_v23_vom_wireArray) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_wiretype_v_io_v23_vom_wireArray)
	}
	return t, nil
}
func (t *wireArrayTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		val, err := &vdl.StringTarget{Value: &t.Value.Name}, error(nil)
		return nil, val, err
	case "Elem":
		val, err := &typeIdTarget{Value: &t.Value.Elem}, error(nil)
		return nil, val, err
	case "Len":
		val, err := &vdl.Uint64Target{Value: &t.Value.Len}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_wiretype_v_io_v23_vom_wireArray)
	}
}
func (t *wireArrayTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *wireArrayTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// wireList represents a type definition for list types.
type wireList struct {
	Name string
	Elem typeId
}

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

func (m *wireList) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_wiretype_v_io_v23_vom_wireList == nil || __VDLTypewiretype4 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	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), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Elem")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Elem.FillVDLTarget(fieldTarget5, __VDLType_wiretype_v_io_v23_vom_typeId); 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 *wireList) MakeVDLTarget() vdl.Target {
	return &wireListTarget{Value: m}
}

type wireListTarget struct {
	Value *wireList
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *wireListTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_wiretype_v_io_v23_vom_wireList) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_wiretype_v_io_v23_vom_wireList)
	}
	return t, nil
}
func (t *wireListTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		val, err := &vdl.StringTarget{Value: &t.Value.Name}, error(nil)
		return nil, val, err
	case "Elem":
		val, err := &typeIdTarget{Value: &t.Value.Elem}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_wiretype_v_io_v23_vom_wireList)
	}
}
func (t *wireListTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *wireListTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// wireSet represents a type definition for set types.
type wireSet struct {
	Name string
	Key  typeId
}

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

func (m *wireSet) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_wiretype_v_io_v23_vom_wireSet == nil || __VDLTypewiretype5 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	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), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Key")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Key.FillVDLTarget(fieldTarget5, __VDLType_wiretype_v_io_v23_vom_typeId); 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 *wireSet) MakeVDLTarget() vdl.Target {
	return &wireSetTarget{Value: m}
}

type wireSetTarget struct {
	Value *wireSet
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *wireSetTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_wiretype_v_io_v23_vom_wireSet) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_wiretype_v_io_v23_vom_wireSet)
	}
	return t, nil
}
func (t *wireSetTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		val, err := &vdl.StringTarget{Value: &t.Value.Name}, error(nil)
		return nil, val, err
	case "Key":
		val, err := &typeIdTarget{Value: &t.Value.Key}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_wiretype_v_io_v23_vom_wireSet)
	}
}
func (t *wireSetTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *wireSetTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// wireMap represents a type definition for map types.
type wireMap struct {
	Name string
	Key  typeId
	Elem typeId
}

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

func (m *wireMap) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_wiretype_v_io_v23_vom_wireMap == nil || __VDLTypewiretype6 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	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), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Key")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Key.FillVDLTarget(fieldTarget5, __VDLType_wiretype_v_io_v23_vom_typeId); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Elem")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Elem.FillVDLTarget(fieldTarget7, __VDLType_wiretype_v_io_v23_vom_typeId); 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 *wireMap) MakeVDLTarget() vdl.Target {
	return &wireMapTarget{Value: m}
}

type wireMapTarget struct {
	Value *wireMap
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *wireMapTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_wiretype_v_io_v23_vom_wireMap) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_wiretype_v_io_v23_vom_wireMap)
	}
	return t, nil
}
func (t *wireMapTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		val, err := &vdl.StringTarget{Value: &t.Value.Name}, error(nil)
		return nil, val, err
	case "Key":
		val, err := &typeIdTarget{Value: &t.Value.Key}, error(nil)
		return nil, val, err
	case "Elem":
		val, err := &typeIdTarget{Value: &t.Value.Elem}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_wiretype_v_io_v23_vom_wireMap)
	}
}
func (t *wireMapTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *wireMapTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// wireField represents a field in a struct or union type.
type wireField struct {
	Name string
	Type typeId
}

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

func (m *wireField) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_wiretype_v_io_v23_vom_wireField == nil || __VDLTypewiretype7 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	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), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Type")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Type.FillVDLTarget(fieldTarget5, __VDLType_wiretype_v_io_v23_vom_typeId); 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 *wireField) MakeVDLTarget() vdl.Target {
	return &wireFieldTarget{Value: m}
}

type wireFieldTarget struct {
	Value *wireField
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *wireFieldTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_wiretype_v_io_v23_vom_wireField) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_wiretype_v_io_v23_vom_wireField)
	}
	return t, nil
}
func (t *wireFieldTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		val, err := &vdl.StringTarget{Value: &t.Value.Name}, error(nil)
		return nil, val, err
	case "Type":
		val, err := &typeIdTarget{Value: &t.Value.Type}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_wiretype_v_io_v23_vom_wireField)
	}
}
func (t *wireFieldTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *wireFieldTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// wireStruct represents a type definition for struct types.
type wireStruct struct {
	Name   string
	Fields []wireField
}

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

func (m *wireStruct) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_wiretype_v_io_v23_vom_wireStruct == nil || __VDLTypewiretype8 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	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), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Fields")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		listTarget6, err := fieldTarget5.StartList(__VDLTypewiretype9, len(m.Fields))
		if err != nil {
			return err
		}
		for i, elem8 := range m.Fields {
			elemTarget7, err := listTarget6.StartElem(i)
			if err != nil {
				return err
			}

			if err := elem8.FillVDLTarget(elemTarget7, __VDLType_wiretype_v_io_v23_vom_wireField); err != nil {
				return err
			}
			if err := listTarget6.FinishElem(elemTarget7); err != nil {
				return err
			}
		}
		if err := fieldTarget5.FinishList(listTarget6); 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 *wireStruct) MakeVDLTarget() vdl.Target {
	return &wireStructTarget{Value: m}
}

type wireStructTarget struct {
	Value *wireStruct
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *wireStructTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_wiretype_v_io_v23_vom_wireStruct) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_wiretype_v_io_v23_vom_wireStruct)
	}
	return t, nil
}
func (t *wireStructTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		val, err := &vdl.StringTarget{Value: &t.Value.Name}, error(nil)
		return nil, val, err
	case "Fields":
		val, err := &wiretype5b5d762e696f2f7632332f766f6d2e776972654669656c64207374727563747b4e616d6520737472696e673b5479706520762e696f2f7632332f766f6d2e7479706549642075696e7436347dTarget{Value: &t.Value.Fields}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_wiretype_v_io_v23_vom_wireStruct)
	}
}
func (t *wireStructTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *wireStructTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type wiretype5b5d762e696f2f7632332f766f6d2e776972654669656c64207374727563747b4e616d6520737472696e673b5479706520762e696f2f7632332f766f6d2e7479706549642075696e7436347dTarget struct {
	Value *[]wireField
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *wiretype5b5d762e696f2f7632332f766f6d2e776972654669656c64207374727563747b4e616d6520737472696e673b5479706520762e696f2f7632332f766f6d2e7479706549642075696e7436347dTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
	if !vdl.Compatible(tt, __VDLTypewiretype9) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLTypewiretype9)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]wireField, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *wiretype5b5d762e696f2f7632332f766f6d2e776972654669656c64207374727563747b4e616d6520737472696e673b5479706520762e696f2f7632332f766f6d2e7479706549642075696e7436347dTarget) StartElem(index int) (elem vdl.Target, _ error) {
	return &wireFieldTarget{Value: &(*t.Value)[index]}, error(nil)
}
func (t *wiretype5b5d762e696f2f7632332f766f6d2e776972654669656c64207374727563747b4e616d6520737472696e673b5479706520762e696f2f7632332f766f6d2e7479706549642075696e7436347dTarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *wiretype5b5d762e696f2f7632332f766f6d2e776972654669656c64207374727563747b4e616d6520737472696e673b5479706520762e696f2f7632332f766f6d2e7479706549642075696e7436347dTarget) FinishList(elem vdl.ListTarget) error {

	return nil
}

// wireUnion represents a type definition for union types.
type wireUnion struct {
	Name   string
	Fields []wireField
}

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

func (m *wireUnion) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_wiretype_v_io_v23_vom_wireUnion == nil || __VDLTypewiretype10 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	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), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Fields")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		listTarget6, err := fieldTarget5.StartList(__VDLTypewiretype9, len(m.Fields))
		if err != nil {
			return err
		}
		for i, elem8 := range m.Fields {
			elemTarget7, err := listTarget6.StartElem(i)
			if err != nil {
				return err
			}

			if err := elem8.FillVDLTarget(elemTarget7, __VDLType_wiretype_v_io_v23_vom_wireField); err != nil {
				return err
			}
			if err := listTarget6.FinishElem(elemTarget7); err != nil {
				return err
			}
		}
		if err := fieldTarget5.FinishList(listTarget6); 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 *wireUnion) MakeVDLTarget() vdl.Target {
	return &wireUnionTarget{Value: m}
}

type wireUnionTarget struct {
	Value *wireUnion
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *wireUnionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_wiretype_v_io_v23_vom_wireUnion) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_wiretype_v_io_v23_vom_wireUnion)
	}
	return t, nil
}
func (t *wireUnionTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		val, err := &vdl.StringTarget{Value: &t.Value.Name}, error(nil)
		return nil, val, err
	case "Fields":
		val, err := &wiretype5b5d762e696f2f7632332f766f6d2e776972654669656c64207374727563747b4e616d6520737472696e673b5479706520762e696f2f7632332f766f6d2e7479706549642075696e7436347dTarget{Value: &t.Value.Fields}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_wiretype_v_io_v23_vom_wireUnion)
	}
}
func (t *wireUnionTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *wireUnionTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// wireOptional represents an type definition for optional types.
type wireOptional struct {
	Name string
	Elem typeId
}

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

func (m *wireOptional) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_wiretype_v_io_v23_vom_wireOptional == nil || __VDLTypewiretype11 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	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), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Elem")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Elem.FillVDLTarget(fieldTarget5, __VDLType_wiretype_v_io_v23_vom_typeId); 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 *wireOptional) MakeVDLTarget() vdl.Target {
	return &wireOptionalTarget{Value: m}
}

type wireOptionalTarget struct {
	Value *wireOptional
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *wireOptionalTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_wiretype_v_io_v23_vom_wireOptional) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_wiretype_v_io_v23_vom_wireOptional)
	}
	return t, nil
}
func (t *wireOptionalTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		val, err := &vdl.StringTarget{Value: &t.Value.Name}, error(nil)
		return nil, val, err
	case "Elem":
		val, err := &typeIdTarget{Value: &t.Value.Elem}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_wiretype_v_io_v23_vom_wireOptional)
	}
}
func (t *wireOptionalTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *wireOptionalTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func init() {
	vdl.Register((*typeId)(nil))
	vdl.Register((*wireType)(nil))
	vdl.Register((*wireNamed)(nil))
	vdl.Register((*wireEnum)(nil))
	vdl.Register((*wireArray)(nil))
	vdl.Register((*wireList)(nil))
	vdl.Register((*wireSet)(nil))
	vdl.Register((*wireMap)(nil))
	vdl.Register((*wireField)(nil))
	vdl.Register((*wireStruct)(nil))
	vdl.Register((*wireUnion)(nil))
	vdl.Register((*wireOptional)(nil))
}

var __VDLTypewiretype3 *vdl.Type = vdl.TypeOf((*wireArray)(nil))
var __VDLTypewiretype1 *vdl.Type = vdl.TypeOf((*wireEnum)(nil))
var __VDLTypewiretype7 *vdl.Type = vdl.TypeOf((*wireField)(nil))
var __VDLTypewiretype4 *vdl.Type = vdl.TypeOf((*wireList)(nil))
var __VDLTypewiretype6 *vdl.Type = vdl.TypeOf((*wireMap)(nil))
var __VDLTypewiretype0 *vdl.Type = vdl.TypeOf((*wireNamed)(nil))
var __VDLTypewiretype11 *vdl.Type = vdl.TypeOf((*wireOptional)(nil))
var __VDLTypewiretype5 *vdl.Type = vdl.TypeOf((*wireSet)(nil))
var __VDLTypewiretype8 *vdl.Type = vdl.TypeOf((*wireStruct)(nil))
var __VDLTypewiretype10 *vdl.Type = vdl.TypeOf((*wireUnion)(nil))
var __VDLTypewiretype2 *vdl.Type = vdl.TypeOf([]string(nil))
var __VDLTypewiretype9 *vdl.Type = vdl.TypeOf([]wireField(nil))
var __VDLType_wiretype_v_io_v23_vom_typeId *vdl.Type = vdl.TypeOf(typeId(0))
var __VDLType_wiretype_v_io_v23_vom_wireArray *vdl.Type = vdl.TypeOf(wireArray{})
var __VDLType_wiretype_v_io_v23_vom_wireEnum *vdl.Type = vdl.TypeOf(wireEnum{})
var __VDLType_wiretype_v_io_v23_vom_wireField *vdl.Type = vdl.TypeOf(wireField{})
var __VDLType_wiretype_v_io_v23_vom_wireList *vdl.Type = vdl.TypeOf(wireList{})
var __VDLType_wiretype_v_io_v23_vom_wireMap *vdl.Type = vdl.TypeOf(wireMap{})
var __VDLType_wiretype_v_io_v23_vom_wireNamed *vdl.Type = vdl.TypeOf(wireNamed{})
var __VDLType_wiretype_v_io_v23_vom_wireOptional *vdl.Type = vdl.TypeOf(wireOptional{})
var __VDLType_wiretype_v_io_v23_vom_wireSet *vdl.Type = vdl.TypeOf(wireSet{})
var __VDLType_wiretype_v_io_v23_vom_wireStruct *vdl.Type = vdl.TypeOf(wireStruct{})
var __VDLType_wiretype_v_io_v23_vom_wireType *vdl.Type = vdl.TypeOf(wireType(wireTypeNamedT{wireNamed{}}))
var __VDLType_wiretype_v_io_v23_vom_wireUnion *vdl.Type = vdl.TypeOf(wireUnion{})

func __VDLEnsureNativeBuilt_wiretype() {
}

// Primitive types.
const WireIdBool = typeId(1)

const WireIdByte = typeId(2)

const WireIdString = typeId(3)

const WireIdUint16 = typeId(4)

const WireIdUint32 = typeId(5)

const WireIdUint64 = typeId(6)

const WireIdInt16 = typeId(7)

const WireIdInt32 = typeId(8)

const WireIdInt64 = typeId(9)

const WireIdFloat32 = typeId(10)

const WireIdFloat64 = typeId(11)

const WireIdComplex64 = typeId(12)

const WireIdComplex128 = typeId(13)

const WireIdTypeObject = typeId(14)

const WireIdAny = typeId(15)

const WireIdInt8 = typeId(16)

// Other commonly used composites.
const WireIdByteList = typeId(39)

const WireIdStringList = typeId(40)

// The first user-defined typeId is 41.
const WireIdFirstUserType = typeId(41)

const WireCtrlNil = byte(224) // Nil in optional or any

const WireCtrlEnd = byte(225) // End of struct or union

const WireCtrlTypeIncomplete = byte(226) // Marks that the type message is incomplete until future messages are received