// 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: base

// Package base is a simple single-file test of vdl functionality.
package base

import (
	"fmt"
	"io"
	"v.io/v23"
	"v.io/v23/context"
	"v.io/v23/i18n"
	"v.io/v23/rpc"
	"v.io/v23/vdl"
	"v.io/v23/verror"
	"v.io/v23/vom"
)

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

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

type NamedBool bool

func (NamedBool) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedBool"`
}) {
}

func (x NamedBool) VDLIsZero() bool {
	return bool(!x)
}

func (x NamedBool) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueBool(__VDLType_bool_1, bool(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedBool) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueBool(); {
	case err != nil:
		return err
	default:
		*x = NamedBool(value)
	}
	return nil
}

type NamedByte byte

func (NamedByte) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedByte"`
}) {
}

func (x NamedByte) VDLIsZero() bool {
	return x == 0
}

func (x NamedByte) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueUint(__VDLType_byte_2, uint64(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedByte) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueUint(8); {
	case err != nil:
		return err
	default:
		*x = NamedByte(value)
	}
	return nil
}

type NamedUint16 uint16

func (NamedUint16) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedUint16"`
}) {
}

func (x NamedUint16) VDLIsZero() bool {
	return x == 0
}

func (x NamedUint16) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueUint(__VDLType_uint16_3, uint64(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedUint16) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueUint(16); {
	case err != nil:
		return err
	default:
		*x = NamedUint16(value)
	}
	return nil
}

type NamedUint32 uint32

func (NamedUint32) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedUint32"`
}) {
}

func (x NamedUint32) VDLIsZero() bool {
	return x == 0
}

func (x NamedUint32) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueUint(__VDLType_uint32_4, uint64(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedUint32) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueUint(32); {
	case err != nil:
		return err
	default:
		*x = NamedUint32(value)
	}
	return nil
}

type NamedUint64 uint64

func (NamedUint64) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedUint64"`
}) {
}

func (x NamedUint64) VDLIsZero() bool {
	return x == 0
}

func (x NamedUint64) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueUint(__VDLType_uint64_5, uint64(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedUint64) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueUint(64); {
	case err != nil:
		return err
	default:
		*x = NamedUint64(value)
	}
	return nil
}

type NamedInt8 int8

func (NamedInt8) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedInt8"`
}) {
}

func (x NamedInt8) VDLIsZero() bool {
	return x == 0
}

func (x NamedInt8) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueInt(__VDLType_int8_6, int64(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedInt8) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueInt(8); {
	case err != nil:
		return err
	default:
		*x = NamedInt8(value)
	}
	return nil
}

type NamedInt16 int16

func (NamedInt16) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedInt16"`
}) {
}

func (x NamedInt16) VDLIsZero() bool {
	return x == 0
}

func (x NamedInt16) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueInt(__VDLType_int16_7, int64(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedInt16) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueInt(16); {
	case err != nil:
		return err
	default:
		*x = NamedInt16(value)
	}
	return nil
}

type NamedInt32 int32

func (NamedInt32) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedInt32"`
}) {
}

func (x NamedInt32) VDLIsZero() bool {
	return x == 0
}

func (x NamedInt32) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueInt(__VDLType_int32_8, int64(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedInt32) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueInt(32); {
	case err != nil:
		return err
	default:
		*x = NamedInt32(value)
	}
	return nil
}

type NamedInt64 int64

func (NamedInt64) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedInt64"`
}) {
}

func (x NamedInt64) VDLIsZero() bool {
	return x == 0
}

func (x NamedInt64) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueInt(__VDLType_int64_9, int64(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedInt64) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueInt(64); {
	case err != nil:
		return err
	default:
		*x = NamedInt64(value)
	}
	return nil
}

type NamedFloat32 float32

func (NamedFloat32) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedFloat32"`
}) {
}

func (x NamedFloat32) VDLIsZero() bool {
	return x == 0
}

func (x NamedFloat32) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueFloat(__VDLType_float32_10, float64(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedFloat32) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueFloat(32); {
	case err != nil:
		return err
	default:
		*x = NamedFloat32(value)
	}
	return nil
}

type NamedFloat64 float64

func (NamedFloat64) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedFloat64"`
}) {
}

func (x NamedFloat64) VDLIsZero() bool {
	return x == 0
}

func (x NamedFloat64) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueFloat(__VDLType_float64_11, float64(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedFloat64) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueFloat(64); {
	case err != nil:
		return err
	default:
		*x = NamedFloat64(value)
	}
	return nil
}

type NamedString string

func (NamedString) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedString"`
}) {
}

func (x NamedString) VDLIsZero() bool {
	return x == ""
}

func (x NamedString) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueString(__VDLType_string_12, string(x)); err != nil {
		return err
	}
	return nil
}

func (x *NamedString) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueString(); {
	case err != nil:
		return err
	default:
		*x = NamedString(value)
	}
	return nil
}

type NamedEnum int

const (
	NamedEnumA NamedEnum = iota
	NamedEnumB
	NamedEnumC
)

// NamedEnumAll holds all labels for NamedEnum.
var NamedEnumAll = [...]NamedEnum{NamedEnumA, NamedEnumB, NamedEnumC}

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

// Set assigns label to x.
func (x *NamedEnum) Set(label string) error {
	switch label {
	case "A", "a":
		*x = NamedEnumA
		return nil
	case "B", "b":
		*x = NamedEnumB
		return nil
	case "C", "c":
		*x = NamedEnumC
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in base.NamedEnum", label)
}

// String returns the string label of x.
func (x NamedEnum) String() string {
	switch x {
	case NamedEnumA:
		return "A"
	case NamedEnumB:
		return "B"
	case NamedEnumC:
		return "C"
	}
	return ""
}

func (NamedEnum) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedEnum"`
	Enum struct{ A, B, C string }
}) {
}

func (x NamedEnum) VDLIsZero() bool {
	return x == NamedEnumA
}

func (x NamedEnum) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueString(__VDLType_enum_13, x.String()); err != nil {
		return err
	}
	return nil
}

func (x *NamedEnum) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueString(); {
	case err != nil:
		return err
	default:
		if err := x.Set(value); err != nil {
			return err
		}
	}
	return nil
}

type NamedArray [2]bool

func (NamedArray) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedArray"`
}) {
}

func (x NamedArray) VDLIsZero() bool {
	return x == NamedArray{}
}

func (x NamedArray) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_array_14); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntryValueBool(vdl.BoolType, elem); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *NamedArray) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(__VDLType_array_14); err != nil {
		return err
	}
	for index := 0; index < 2; index++ {
		switch done, elem, err := dec.NextEntryValueBool(); {
		case err != nil:
			return err
		case done:
			return fmt.Errorf("short array, got len %d < 2 %T)", index, *x)
		default:
			x[index] = elem
		}
	}
	switch done, err := dec.NextEntry(); {
	case err != nil:
		return err
	case !done:
		return fmt.Errorf("long array, got len > 2 %T", *x)
	}
	return dec.FinishValue()
}

type NamedList []uint32

func (NamedList) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedList"`
}) {
}

func (x NamedList) VDLIsZero() bool {
	return len(x) == 0
}

func (x NamedList) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_list_15); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntryValueUint(vdl.Uint32Type, uint64(elem)); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *NamedList) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(__VDLType_list_15); err != nil {
		return err
	}
	if len := dec.LenHint(); len > 0 {
		*x = make(NamedList, 0, len)
	} else {
		*x = nil
	}
	for {
		switch done, elem, err := dec.NextEntryValueUint(32); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		default:
			*x = append(*x, uint32(elem))
		}
	}
}

type NamedSet map[string]struct{}

func (NamedSet) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedSet"`
}) {
}

func (x NamedSet) VDLIsZero() bool {
	return len(x) == 0
}

func (x NamedSet) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_set_16); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for key := range x {
		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *NamedSet) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(__VDLType_set_16); err != nil {
		return err
	}
	var tmpMap NamedSet
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(NamedSet, len)
	}
	for {
		switch done, key, err := dec.NextEntryValueString(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		default:
			if tmpMap == nil {
				tmpMap = make(NamedSet)
			}
			tmpMap[key] = struct{}{}
		}
	}
}

type NamedMap map[string]float32

func (NamedMap) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedMap"`
}) {
}

func (x NamedMap) VDLIsZero() bool {
	return len(x) == 0
}

func (x NamedMap) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_map_17); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for key, elem := range x {
		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
			return err
		}
		if err := enc.WriteValueFloat(vdl.Float32Type, float64(elem)); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *NamedMap) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(__VDLType_map_17); err != nil {
		return err
	}
	var tmpMap NamedMap
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(NamedMap, len)
	}
	for {
		switch done, key, err := dec.NextEntryValueString(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		default:
			var elem float32
			switch value, err := dec.ReadValueFloat(32); {
			case err != nil:
				return err
			default:
				elem = float32(value)
			}
			if tmpMap == nil {
				tmpMap = make(NamedMap)
			}
			tmpMap[key] = elem
		}
	}
}

type NamedStruct struct {
	A bool
	B string
	C int32
}

func (NamedStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedStruct"`
}) {
}

func (x NamedStruct) VDLIsZero() bool {
	return x == NamedStruct{}
}

func (x NamedStruct) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_18); err != nil {
		return err
	}
	if x.A {
		if err := enc.NextFieldValueBool("A", vdl.BoolType, x.A); err != nil {
			return err
		}
	}
	if x.B != "" {
		if err := enc.NextFieldValueString("B", vdl.StringType, x.B); err != nil {
			return err
		}
	}
	if x.C != 0 {
		if err := enc.NextFieldValueInt("C", vdl.Int32Type, int64(x.C)); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *NamedStruct) VDLRead(dec vdl.Decoder) error {
	*x = NamedStruct{}
	if err := dec.StartValue(__VDLType_struct_18); err != nil {
		return err
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "A":
			switch value, err := dec.ReadValueBool(); {
			case err != nil:
				return err
			default:
				x.A = value
			}
		case "B":
			switch value, err := dec.ReadValueString(); {
			case err != nil:
				return err
			default:
				x.B = value
			}
		case "C":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.C = int32(value)
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

type (
	// NamedUnion represents any single field of the NamedUnion union type.
	NamedUnion 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 NamedUnion union type.
		__VDLReflect(__NamedUnionReflect)
		VDLIsZero() bool
		VDLWrite(vdl.Encoder) error
	}
	// NamedUnionA represents field A of the NamedUnion union type.
	NamedUnionA struct{ Value bool }
	// NamedUnionB represents field B of the NamedUnion union type.
	NamedUnionB struct{ Value string }
	// NamedUnionC represents field C of the NamedUnion union type.
	NamedUnionC struct{ Value int32 }
	// __NamedUnionReflect describes the NamedUnion union type.
	__NamedUnionReflect struct {
		Name  string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NamedUnion"`
		Type  NamedUnion
		Union struct {
			A NamedUnionA
			B NamedUnionB
			C NamedUnionC
		}
	}
)

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

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

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

func (x NamedUnionA) VDLIsZero() bool {
	return !x.Value
}

func (x NamedUnionB) VDLIsZero() bool {
	return false
}

func (x NamedUnionC) VDLIsZero() bool {
	return false
}

func (x NamedUnionA) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_union_19); err != nil {
		return err
	}
	if err := enc.NextFieldValueBool("A", vdl.BoolType, x.Value); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x NamedUnionB) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_union_19); err != nil {
		return err
	}
	if err := enc.NextFieldValueString("B", vdl.StringType, x.Value); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x NamedUnionC) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_union_19); err != nil {
		return err
	}
	if err := enc.NextFieldValueInt("C", vdl.Int32Type, int64(x.Value)); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func VDLReadNamedUnion(dec vdl.Decoder, x *NamedUnion) error {
	if err := dec.StartValue(__VDLType_union_19); err != nil {
		return err
	}
	f, err := dec.NextField()
	if err != nil {
		return err
	}
	switch f {
	case "A":
		var field NamedUnionA
		switch value, err := dec.ReadValueBool(); {
		case err != nil:
			return err
		default:
			field.Value = value
		}
		*x = field
	case "B":
		var field NamedUnionB
		switch value, err := dec.ReadValueString(); {
		case err != nil:
			return err
		default:
			field.Value = value
		}
		*x = field
	case "C":
		var field NamedUnionC
		switch value, err := dec.ReadValueInt(32); {
		case err != nil:
			return err
		default:
			field.Value = int32(value)
		}
		*x = field
	case "":
		return fmt.Errorf("missing field in union %T, from %v", x, dec.Type())
	default:
		return fmt.Errorf("field %q not in union %T, from %v", f, x, dec.Type())
	}
	switch f, err := dec.NextField(); {
	case err != nil:
		return err
	case f != "":
		return fmt.Errorf("extra field %q in union %T, from %v", f, x, dec.Type())
	}
	return dec.FinishValue()
}

type Scalars struct {
	A0  bool
	A1  byte
	A2  uint16
	A3  uint32
	A4  uint64
	A5  int8
	A6  int16
	A7  int32
	A8  int64
	A9  float32
	A10 float64
	A11 string
	A12 error
	A13 *vom.RawBytes
	A14 *vdl.Type
	B0  NamedBool
	B1  NamedByte
	B2  NamedUint16
	B3  NamedUint32
	B4  NamedUint64
	B5  NamedInt8
	B6  NamedInt16
	B7  NamedInt32
	B8  NamedInt64
	B9  NamedFloat32
	B10 NamedFloat64
	B11 NamedString
	B12 NamedEnum
	B13 NamedUnion
}

func (Scalars) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.Scalars"`
}) {
}

func (x Scalars) VDLIsZero() bool {
	if x.A0 {
		return false
	}
	if x.A1 != 0 {
		return false
	}
	if x.A2 != 0 {
		return false
	}
	if x.A3 != 0 {
		return false
	}
	if x.A4 != 0 {
		return false
	}
	if x.A5 != 0 {
		return false
	}
	if x.A6 != 0 {
		return false
	}
	if x.A7 != 0 {
		return false
	}
	if x.A8 != 0 {
		return false
	}
	if x.A9 != 0 {
		return false
	}
	if x.A10 != 0 {
		return false
	}
	if x.A11 != "" {
		return false
	}
	if x.A12 != nil {
		return false
	}
	if x.A13 != nil && !x.A13.VDLIsZero() {
		return false
	}
	if x.A14 != nil && x.A14 != vdl.AnyType {
		return false
	}
	if x.B0 {
		return false
	}
	if x.B1 != 0 {
		return false
	}
	if x.B2 != 0 {
		return false
	}
	if x.B3 != 0 {
		return false
	}
	if x.B4 != 0 {
		return false
	}
	if x.B5 != 0 {
		return false
	}
	if x.B6 != 0 {
		return false
	}
	if x.B7 != 0 {
		return false
	}
	if x.B8 != 0 {
		return false
	}
	if x.B9 != 0 {
		return false
	}
	if x.B10 != 0 {
		return false
	}
	if x.B11 != "" {
		return false
	}
	if x.B12 != NamedEnumA {
		return false
	}
	if x.B13 != nil && !x.B13.VDLIsZero() {
		return false
	}
	return true
}

func (x Scalars) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_20); err != nil {
		return err
	}
	if x.A0 {
		if err := enc.NextFieldValueBool("A0", vdl.BoolType, x.A0); err != nil {
			return err
		}
	}
	if x.A1 != 0 {
		if err := enc.NextFieldValueUint("A1", vdl.ByteType, uint64(x.A1)); err != nil {
			return err
		}
	}
	if x.A2 != 0 {
		if err := enc.NextFieldValueUint("A2", vdl.Uint16Type, uint64(x.A2)); err != nil {
			return err
		}
	}
	if x.A3 != 0 {
		if err := enc.NextFieldValueUint("A3", vdl.Uint32Type, uint64(x.A3)); err != nil {
			return err
		}
	}
	if x.A4 != 0 {
		if err := enc.NextFieldValueUint("A4", vdl.Uint64Type, x.A4); err != nil {
			return err
		}
	}
	if x.A5 != 0 {
		if err := enc.NextFieldValueInt("A5", vdl.Int8Type, int64(x.A5)); err != nil {
			return err
		}
	}
	if x.A6 != 0 {
		if err := enc.NextFieldValueInt("A6", vdl.Int16Type, int64(x.A6)); err != nil {
			return err
		}
	}
	if x.A7 != 0 {
		if err := enc.NextFieldValueInt("A7", vdl.Int32Type, int64(x.A7)); err != nil {
			return err
		}
	}
	if x.A8 != 0 {
		if err := enc.NextFieldValueInt("A8", vdl.Int64Type, x.A8); err != nil {
			return err
		}
	}
	if x.A9 != 0 {
		if err := enc.NextFieldValueFloat("A9", vdl.Float32Type, float64(x.A9)); err != nil {
			return err
		}
	}
	if x.A10 != 0 {
		if err := enc.NextFieldValueFloat("A10", vdl.Float64Type, x.A10); err != nil {
			return err
		}
	}
	if x.A11 != "" {
		if err := enc.NextFieldValueString("A11", vdl.StringType, x.A11); err != nil {
			return err
		}
	}
	if x.A12 != nil {
		if err := enc.NextField("A12"); err != nil {
			return err
		}
		if err := verror.VDLWrite(enc, x.A12); err != nil {
			return err
		}
	}
	if x.A13 != nil && !x.A13.VDLIsZero() {
		if err := enc.NextField("A13"); err != nil {
			return err
		}
		if err := x.A13.VDLWrite(enc); err != nil {
			return err
		}
	}
	if x.A14 != nil && x.A14 != vdl.AnyType {
		if err := enc.NextFieldValueTypeObject("A14", x.A14); err != nil {
			return err
		}
	}
	if x.B0 {
		if err := enc.NextFieldValueBool("B0", __VDLType_bool_1, bool(x.B0)); err != nil {
			return err
		}
	}
	if x.B1 != 0 {
		if err := enc.NextFieldValueUint("B1", __VDLType_byte_2, uint64(x.B1)); err != nil {
			return err
		}
	}
	if x.B2 != 0 {
		if err := enc.NextFieldValueUint("B2", __VDLType_uint16_3, uint64(x.B2)); err != nil {
			return err
		}
	}
	if x.B3 != 0 {
		if err := enc.NextFieldValueUint("B3", __VDLType_uint32_4, uint64(x.B3)); err != nil {
			return err
		}
	}
	if x.B4 != 0 {
		if err := enc.NextFieldValueUint("B4", __VDLType_uint64_5, uint64(x.B4)); err != nil {
			return err
		}
	}
	if x.B5 != 0 {
		if err := enc.NextFieldValueInt("B5", __VDLType_int8_6, int64(x.B5)); err != nil {
			return err
		}
	}
	if x.B6 != 0 {
		if err := enc.NextFieldValueInt("B6", __VDLType_int16_7, int64(x.B6)); err != nil {
			return err
		}
	}
	if x.B7 != 0 {
		if err := enc.NextFieldValueInt("B7", __VDLType_int32_8, int64(x.B7)); err != nil {
			return err
		}
	}
	if x.B8 != 0 {
		if err := enc.NextFieldValueInt("B8", __VDLType_int64_9, int64(x.B8)); err != nil {
			return err
		}
	}
	if x.B9 != 0 {
		if err := enc.NextFieldValueFloat("B9", __VDLType_float32_10, float64(x.B9)); err != nil {
			return err
		}
	}
	if x.B10 != 0 {
		if err := enc.NextFieldValueFloat("B10", __VDLType_float64_11, float64(x.B10)); err != nil {
			return err
		}
	}
	if x.B11 != "" {
		if err := enc.NextFieldValueString("B11", __VDLType_string_12, string(x.B11)); err != nil {
			return err
		}
	}
	if x.B12 != NamedEnumA {
		if err := enc.NextFieldValueString("B12", __VDLType_enum_13, x.B12.String()); err != nil {
			return err
		}
	}
	if x.B13 != nil && !x.B13.VDLIsZero() {
		if err := enc.NextField("B13"); err != nil {
			return err
		}
		if err := x.B13.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *Scalars) VDLRead(dec vdl.Decoder) error {
	*x = Scalars{
		A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
		A14: vdl.AnyType,
		B13: NamedUnionA{},
	}
	if err := dec.StartValue(__VDLType_struct_20); err != nil {
		return err
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "A0":
			switch value, err := dec.ReadValueBool(); {
			case err != nil:
				return err
			default:
				x.A0 = value
			}
		case "A1":
			switch value, err := dec.ReadValueUint(8); {
			case err != nil:
				return err
			default:
				x.A1 = byte(value)
			}
		case "A2":
			switch value, err := dec.ReadValueUint(16); {
			case err != nil:
				return err
			default:
				x.A2 = uint16(value)
			}
		case "A3":
			switch value, err := dec.ReadValueUint(32); {
			case err != nil:
				return err
			default:
				x.A3 = uint32(value)
			}
		case "A4":
			switch value, err := dec.ReadValueUint(64); {
			case err != nil:
				return err
			default:
				x.A4 = value
			}
		case "A5":
			switch value, err := dec.ReadValueInt(8); {
			case err != nil:
				return err
			default:
				x.A5 = int8(value)
			}
		case "A6":
			switch value, err := dec.ReadValueInt(16); {
			case err != nil:
				return err
			default:
				x.A6 = int16(value)
			}
		case "A7":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.A7 = int32(value)
			}
		case "A8":
			switch value, err := dec.ReadValueInt(64); {
			case err != nil:
				return err
			default:
				x.A8 = value
			}
		case "A9":
			switch value, err := dec.ReadValueFloat(32); {
			case err != nil:
				return err
			default:
				x.A9 = float32(value)
			}
		case "A10":
			switch value, err := dec.ReadValueFloat(64); {
			case err != nil:
				return err
			default:
				x.A10 = value
			}
		case "A11":
			switch value, err := dec.ReadValueString(); {
			case err != nil:
				return err
			default:
				x.A11 = value
			}
		case "A12":
			if err := verror.VDLRead(dec, &x.A12); err != nil {
				return err
			}
		case "A13":
			x.A13 = new(vom.RawBytes)
			if err := x.A13.VDLRead(dec); err != nil {
				return err
			}
		case "A14":
			switch value, err := dec.ReadValueTypeObject(); {
			case err != nil:
				return err
			default:
				x.A14 = value
			}
		case "B0":
			switch value, err := dec.ReadValueBool(); {
			case err != nil:
				return err
			default:
				x.B0 = NamedBool(value)
			}
		case "B1":
			switch value, err := dec.ReadValueUint(8); {
			case err != nil:
				return err
			default:
				x.B1 = NamedByte(value)
			}
		case "B2":
			switch value, err := dec.ReadValueUint(16); {
			case err != nil:
				return err
			default:
				x.B2 = NamedUint16(value)
			}
		case "B3":
			switch value, err := dec.ReadValueUint(32); {
			case err != nil:
				return err
			default:
				x.B3 = NamedUint32(value)
			}
		case "B4":
			switch value, err := dec.ReadValueUint(64); {
			case err != nil:
				return err
			default:
				x.B4 = NamedUint64(value)
			}
		case "B5":
			switch value, err := dec.ReadValueInt(8); {
			case err != nil:
				return err
			default:
				x.B5 = NamedInt8(value)
			}
		case "B6":
			switch value, err := dec.ReadValueInt(16); {
			case err != nil:
				return err
			default:
				x.B6 = NamedInt16(value)
			}
		case "B7":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.B7 = NamedInt32(value)
			}
		case "B8":
			switch value, err := dec.ReadValueInt(64); {
			case err != nil:
				return err
			default:
				x.B8 = NamedInt64(value)
			}
		case "B9":
			switch value, err := dec.ReadValueFloat(32); {
			case err != nil:
				return err
			default:
				x.B9 = NamedFloat32(value)
			}
		case "B10":
			switch value, err := dec.ReadValueFloat(64); {
			case err != nil:
				return err
			default:
				x.B10 = NamedFloat64(value)
			}
		case "B11":
			switch value, err := dec.ReadValueString(); {
			case err != nil:
				return err
			default:
				x.B11 = NamedString(value)
			}
		case "B12":
			switch value, err := dec.ReadValueString(); {
			case err != nil:
				return err
			default:
				if err := x.B12.Set(value); err != nil {
					return err
				}
			}
		case "B13":
			if err := VDLReadNamedUnion(dec, &x.B13); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

// These are all scalars that may be used as map or set keys.
type KeyScalars struct {
	A0  bool
	A1  byte
	A2  uint16
	A3  uint32
	A4  uint64
	A5  int8
	A6  int16
	A7  int32
	A8  int64
	A9  float32
	A10 float64
	A11 string
	B0  NamedBool
	B1  NamedByte
	B2  NamedUint16
	B3  NamedUint32
	B4  NamedUint64
	B5  NamedInt8
	B6  NamedInt16
	B7  NamedInt32
	B8  NamedInt64
	B9  NamedFloat32
	B10 NamedFloat64
	B13 NamedString
}

func (KeyScalars) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.KeyScalars"`
}) {
}

func (x KeyScalars) VDLIsZero() bool {
	return x == KeyScalars{}
}

func (x KeyScalars) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_21); err != nil {
		return err
	}
	if x.A0 {
		if err := enc.NextFieldValueBool("A0", vdl.BoolType, x.A0); err != nil {
			return err
		}
	}
	if x.A1 != 0 {
		if err := enc.NextFieldValueUint("A1", vdl.ByteType, uint64(x.A1)); err != nil {
			return err
		}
	}
	if x.A2 != 0 {
		if err := enc.NextFieldValueUint("A2", vdl.Uint16Type, uint64(x.A2)); err != nil {
			return err
		}
	}
	if x.A3 != 0 {
		if err := enc.NextFieldValueUint("A3", vdl.Uint32Type, uint64(x.A3)); err != nil {
			return err
		}
	}
	if x.A4 != 0 {
		if err := enc.NextFieldValueUint("A4", vdl.Uint64Type, x.A4); err != nil {
			return err
		}
	}
	if x.A5 != 0 {
		if err := enc.NextFieldValueInt("A5", vdl.Int8Type, int64(x.A5)); err != nil {
			return err
		}
	}
	if x.A6 != 0 {
		if err := enc.NextFieldValueInt("A6", vdl.Int16Type, int64(x.A6)); err != nil {
			return err
		}
	}
	if x.A7 != 0 {
		if err := enc.NextFieldValueInt("A7", vdl.Int32Type, int64(x.A7)); err != nil {
			return err
		}
	}
	if x.A8 != 0 {
		if err := enc.NextFieldValueInt("A8", vdl.Int64Type, x.A8); err != nil {
			return err
		}
	}
	if x.A9 != 0 {
		if err := enc.NextFieldValueFloat("A9", vdl.Float32Type, float64(x.A9)); err != nil {
			return err
		}
	}
	if x.A10 != 0 {
		if err := enc.NextFieldValueFloat("A10", vdl.Float64Type, x.A10); err != nil {
			return err
		}
	}
	if x.A11 != "" {
		if err := enc.NextFieldValueString("A11", vdl.StringType, x.A11); err != nil {
			return err
		}
	}
	if x.B0 {
		if err := enc.NextFieldValueBool("B0", __VDLType_bool_1, bool(x.B0)); err != nil {
			return err
		}
	}
	if x.B1 != 0 {
		if err := enc.NextFieldValueUint("B1", __VDLType_byte_2, uint64(x.B1)); err != nil {
			return err
		}
	}
	if x.B2 != 0 {
		if err := enc.NextFieldValueUint("B2", __VDLType_uint16_3, uint64(x.B2)); err != nil {
			return err
		}
	}
	if x.B3 != 0 {
		if err := enc.NextFieldValueUint("B3", __VDLType_uint32_4, uint64(x.B3)); err != nil {
			return err
		}
	}
	if x.B4 != 0 {
		if err := enc.NextFieldValueUint("B4", __VDLType_uint64_5, uint64(x.B4)); err != nil {
			return err
		}
	}
	if x.B5 != 0 {
		if err := enc.NextFieldValueInt("B5", __VDLType_int8_6, int64(x.B5)); err != nil {
			return err
		}
	}
	if x.B6 != 0 {
		if err := enc.NextFieldValueInt("B6", __VDLType_int16_7, int64(x.B6)); err != nil {
			return err
		}
	}
	if x.B7 != 0 {
		if err := enc.NextFieldValueInt("B7", __VDLType_int32_8, int64(x.B7)); err != nil {
			return err
		}
	}
	if x.B8 != 0 {
		if err := enc.NextFieldValueInt("B8", __VDLType_int64_9, int64(x.B8)); err != nil {
			return err
		}
	}
	if x.B9 != 0 {
		if err := enc.NextFieldValueFloat("B9", __VDLType_float32_10, float64(x.B9)); err != nil {
			return err
		}
	}
	if x.B10 != 0 {
		if err := enc.NextFieldValueFloat("B10", __VDLType_float64_11, float64(x.B10)); err != nil {
			return err
		}
	}
	if x.B13 != "" {
		if err := enc.NextFieldValueString("B13", __VDLType_string_12, string(x.B13)); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *KeyScalars) VDLRead(dec vdl.Decoder) error {
	*x = KeyScalars{}
	if err := dec.StartValue(__VDLType_struct_21); err != nil {
		return err
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "A0":
			switch value, err := dec.ReadValueBool(); {
			case err != nil:
				return err
			default:
				x.A0 = value
			}
		case "A1":
			switch value, err := dec.ReadValueUint(8); {
			case err != nil:
				return err
			default:
				x.A1 = byte(value)
			}
		case "A2":
			switch value, err := dec.ReadValueUint(16); {
			case err != nil:
				return err
			default:
				x.A2 = uint16(value)
			}
		case "A3":
			switch value, err := dec.ReadValueUint(32); {
			case err != nil:
				return err
			default:
				x.A3 = uint32(value)
			}
		case "A4":
			switch value, err := dec.ReadValueUint(64); {
			case err != nil:
				return err
			default:
				x.A4 = value
			}
		case "A5":
			switch value, err := dec.ReadValueInt(8); {
			case err != nil:
				return err
			default:
				x.A5 = int8(value)
			}
		case "A6":
			switch value, err := dec.ReadValueInt(16); {
			case err != nil:
				return err
			default:
				x.A6 = int16(value)
			}
		case "A7":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.A7 = int32(value)
			}
		case "A8":
			switch value, err := dec.ReadValueInt(64); {
			case err != nil:
				return err
			default:
				x.A8 = value
			}
		case "A9":
			switch value, err := dec.ReadValueFloat(32); {
			case err != nil:
				return err
			default:
				x.A9 = float32(value)
			}
		case "A10":
			switch value, err := dec.ReadValueFloat(64); {
			case err != nil:
				return err
			default:
				x.A10 = value
			}
		case "A11":
			switch value, err := dec.ReadValueString(); {
			case err != nil:
				return err
			default:
				x.A11 = value
			}
		case "B0":
			switch value, err := dec.ReadValueBool(); {
			case err != nil:
				return err
			default:
				x.B0 = NamedBool(value)
			}
		case "B1":
			switch value, err := dec.ReadValueUint(8); {
			case err != nil:
				return err
			default:
				x.B1 = NamedByte(value)
			}
		case "B2":
			switch value, err := dec.ReadValueUint(16); {
			case err != nil:
				return err
			default:
				x.B2 = NamedUint16(value)
			}
		case "B3":
			switch value, err := dec.ReadValueUint(32); {
			case err != nil:
				return err
			default:
				x.B3 = NamedUint32(value)
			}
		case "B4":
			switch value, err := dec.ReadValueUint(64); {
			case err != nil:
				return err
			default:
				x.B4 = NamedUint64(value)
			}
		case "B5":
			switch value, err := dec.ReadValueInt(8); {
			case err != nil:
				return err
			default:
				x.B5 = NamedInt8(value)
			}
		case "B6":
			switch value, err := dec.ReadValueInt(16); {
			case err != nil:
				return err
			default:
				x.B6 = NamedInt16(value)
			}
		case "B7":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.B7 = NamedInt32(value)
			}
		case "B8":
			switch value, err := dec.ReadValueInt(64); {
			case err != nil:
				return err
			default:
				x.B8 = NamedInt64(value)
			}
		case "B9":
			switch value, err := dec.ReadValueFloat(32); {
			case err != nil:
				return err
			default:
				x.B9 = NamedFloat32(value)
			}
		case "B10":
			switch value, err := dec.ReadValueFloat(64); {
			case err != nil:
				return err
			default:
				x.B10 = NamedFloat64(value)
			}
		case "B13":
			switch value, err := dec.ReadValueString(); {
			case err != nil:
				return err
			default:
				x.B13 = NamedString(value)
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

type ScalarsArray [2]Scalars

func (ScalarsArray) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.ScalarsArray"`
}) {
}

func (x ScalarsArray) VDLIsZero() bool {
	for _, elem := range x {
		if !elem.VDLIsZero() {
			return false
		}
	}
	return true
}

func (x ScalarsArray) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_array_22); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := elem.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *ScalarsArray) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(__VDLType_array_22); err != nil {
		return err
	}
	for index := 0; index < 2; index++ {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return fmt.Errorf("short array, got len %d < 2 %T)", index, *x)
		default:
			if err := x[index].VDLRead(dec); err != nil {
				return err
			}
		}
	}
	switch done, err := dec.NextEntry(); {
	case err != nil:
		return err
	case !done:
		return fmt.Errorf("long array, got len > 2 %T", *x)
	}
	return dec.FinishValue()
}

type Composites struct {
	A0 Scalars
	A1 ScalarsArray
	A2 []Scalars
	A3 map[KeyScalars]struct{}
	A4 map[string]Scalars
}

func (Composites) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.Composites"`
}) {
}

func (x Composites) VDLIsZero() bool {
	if !x.A0.VDLIsZero() {
		return false
	}
	if !x.A1.VDLIsZero() {
		return false
	}
	if len(x.A2) != 0 {
		return false
	}
	if len(x.A3) != 0 {
		return false
	}
	if len(x.A4) != 0 {
		return false
	}
	return true
}

func (x Composites) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_23); err != nil {
		return err
	}
	if !x.A0.VDLIsZero() {
		if err := enc.NextField("A0"); err != nil {
			return err
		}
		if err := x.A0.VDLWrite(enc); err != nil {
			return err
		}
	}
	if !x.A1.VDLIsZero() {
		if err := enc.NextField("A1"); err != nil {
			return err
		}
		if err := x.A1.VDLWrite(enc); err != nil {
			return err
		}
	}
	if len(x.A2) != 0 {
		if err := enc.NextField("A2"); err != nil {
			return err
		}
		if err := __VDLWriteAnon_list_1(enc, x.A2); err != nil {
			return err
		}
	}
	if len(x.A3) != 0 {
		if err := enc.NextField("A3"); err != nil {
			return err
		}
		if err := __VDLWriteAnon_set_2(enc, x.A3); err != nil {
			return err
		}
	}
	if len(x.A4) != 0 {
		if err := enc.NextField("A4"); err != nil {
			return err
		}
		if err := __VDLWriteAnon_map_3(enc, x.A4); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_list_1(enc vdl.Encoder, x []Scalars) error {
	if err := enc.StartValue(__VDLType_list_24); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := elem.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_set_2(enc vdl.Encoder, x map[KeyScalars]struct{}) error {
	if err := enc.StartValue(__VDLType_set_25); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for key := range x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := key.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_map_3(enc vdl.Encoder, x map[string]Scalars) error {
	if err := enc.StartValue(__VDLType_map_26); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for key, elem := range x {
		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
			return err
		}
		if err := elem.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *Composites) VDLRead(dec vdl.Decoder) error {
	*x = Composites{
		A0: Scalars{
			A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
			A14: vdl.AnyType,
			B13: NamedUnionA{},
		},
		A1: ScalarsArray{
			{
				A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
				A14: vdl.AnyType,
				B13: NamedUnionA{},
			},
			{
				A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
				A14: vdl.AnyType,
				B13: NamedUnionA{},
			},
		},
	}
	if err := dec.StartValue(__VDLType_struct_23); err != nil {
		return err
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "A0":
			if err := x.A0.VDLRead(dec); err != nil {
				return err
			}
		case "A1":
			if err := x.A1.VDLRead(dec); err != nil {
				return err
			}
		case "A2":
			if err := __VDLReadAnon_list_1(dec, &x.A2); err != nil {
				return err
			}
		case "A3":
			if err := __VDLReadAnon_set_2(dec, &x.A3); err != nil {
				return err
			}
		case "A4":
			if err := __VDLReadAnon_map_3(dec, &x.A4); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLReadAnon_list_1(dec vdl.Decoder, x *[]Scalars) error {
	if err := dec.StartValue(__VDLType_list_24); err != nil {
		return err
	}
	if len := dec.LenHint(); len > 0 {
		*x = make([]Scalars, 0, len)
	} else {
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		default:
			var elem Scalars
			if err := elem.VDLRead(dec); err != nil {
				return err
			}
			*x = append(*x, elem)
		}
	}
}

func __VDLReadAnon_set_2(dec vdl.Decoder, x *map[KeyScalars]struct{}) error {
	if err := dec.StartValue(__VDLType_set_25); err != nil {
		return err
	}
	var tmpMap map[KeyScalars]struct{}
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[KeyScalars]struct{}, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		default:
			var key KeyScalars
			if err := key.VDLRead(dec); err != nil {
				return err
			}
			if tmpMap == nil {
				tmpMap = make(map[KeyScalars]struct{})
			}
			tmpMap[key] = struct{}{}
		}
	}
}

func __VDLReadAnon_map_3(dec vdl.Decoder, x *map[string]Scalars) error {
	if err := dec.StartValue(__VDLType_map_26); err != nil {
		return err
	}
	var tmpMap map[string]Scalars
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[string]Scalars, len)
	}
	for {
		switch done, key, err := dec.NextEntryValueString(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		default:
			var elem Scalars
			if err := elem.VDLRead(dec); err != nil {
				return err
			}
			if tmpMap == nil {
				tmpMap = make(map[string]Scalars)
			}
			tmpMap[key] = elem
		}
	}
}

type CompositesArray [2]Composites

func (CompositesArray) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.CompositesArray"`
}) {
}

func (x CompositesArray) VDLIsZero() bool {
	for _, elem := range x {
		if !elem.VDLIsZero() {
			return false
		}
	}
	return true
}

func (x CompositesArray) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_array_27); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := elem.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *CompositesArray) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(__VDLType_array_27); err != nil {
		return err
	}
	for index := 0; index < 2; index++ {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return fmt.Errorf("short array, got len %d < 2 %T)", index, *x)
		default:
			if err := x[index].VDLRead(dec); err != nil {
				return err
			}
		}
	}
	switch done, err := dec.NextEntry(); {
	case err != nil:
		return err
	case !done:
		return fmt.Errorf("long array, got len > 2 %T", *x)
	}
	return dec.FinishValue()
}

type CompComp struct {
	A0 Composites
	A1 CompositesArray
	A2 []Composites
	A3 map[string]Composites
	A4 map[KeyScalars][]map[string]Composites
}

func (CompComp) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.CompComp"`
}) {
}

func (x CompComp) VDLIsZero() bool {
	if !x.A0.VDLIsZero() {
		return false
	}
	if !x.A1.VDLIsZero() {
		return false
	}
	if len(x.A2) != 0 {
		return false
	}
	if len(x.A3) != 0 {
		return false
	}
	if len(x.A4) != 0 {
		return false
	}
	return true
}

func (x CompComp) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_28); err != nil {
		return err
	}
	if !x.A0.VDLIsZero() {
		if err := enc.NextField("A0"); err != nil {
			return err
		}
		if err := x.A0.VDLWrite(enc); err != nil {
			return err
		}
	}
	if !x.A1.VDLIsZero() {
		if err := enc.NextField("A1"); err != nil {
			return err
		}
		if err := x.A1.VDLWrite(enc); err != nil {
			return err
		}
	}
	if len(x.A2) != 0 {
		if err := enc.NextField("A2"); err != nil {
			return err
		}
		if err := __VDLWriteAnon_list_4(enc, x.A2); err != nil {
			return err
		}
	}
	if len(x.A3) != 0 {
		if err := enc.NextField("A3"); err != nil {
			return err
		}
		if err := __VDLWriteAnon_map_5(enc, x.A3); err != nil {
			return err
		}
	}
	if len(x.A4) != 0 {
		if err := enc.NextField("A4"); err != nil {
			return err
		}
		if err := __VDLWriteAnon_map_6(enc, x.A4); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_list_4(enc vdl.Encoder, x []Composites) error {
	if err := enc.StartValue(__VDLType_list_29); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := elem.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_map_5(enc vdl.Encoder, x map[string]Composites) error {
	if err := enc.StartValue(__VDLType_map_30); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for key, elem := range x {
		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
			return err
		}
		if err := elem.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_map_6(enc vdl.Encoder, x map[KeyScalars][]map[string]Composites) error {
	if err := enc.StartValue(__VDLType_map_31); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for key, elem := range x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := key.VDLWrite(enc); err != nil {
			return err
		}
		if err := __VDLWriteAnon_list_7(enc, elem); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func __VDLWriteAnon_list_7(enc vdl.Encoder, x []map[string]Composites) error {
	if err := enc.StartValue(__VDLType_list_32); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if err := __VDLWriteAnon_map_5(enc, elem); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *CompComp) VDLRead(dec vdl.Decoder) error {
	*x = CompComp{
		A0: Composites{
			A0: Scalars{
				A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
				A14: vdl.AnyType,
				B13: NamedUnionA{},
			},
			A1: ScalarsArray{
				{
					A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
					A14: vdl.AnyType,
					B13: NamedUnionA{},
				},
				{
					A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
					A14: vdl.AnyType,
					B13: NamedUnionA{},
				},
			},
		},
		A1: CompositesArray{
			{
				A0: Scalars{
					A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
					A14: vdl.AnyType,
					B13: NamedUnionA{},
				},
				A1: ScalarsArray{
					{
						A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
						A14: vdl.AnyType,
						B13: NamedUnionA{},
					},
					{
						A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
						A14: vdl.AnyType,
						B13: NamedUnionA{},
					},
				},
			},
			{
				A0: Scalars{
					A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
					A14: vdl.AnyType,
					B13: NamedUnionA{},
				},
				A1: ScalarsArray{
					{
						A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
						A14: vdl.AnyType,
						B13: NamedUnionA{},
					},
					{
						A13: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
						A14: vdl.AnyType,
						B13: NamedUnionA{},
					},
				},
			},
		},
	}
	if err := dec.StartValue(__VDLType_struct_28); err != nil {
		return err
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "A0":
			if err := x.A0.VDLRead(dec); err != nil {
				return err
			}
		case "A1":
			if err := x.A1.VDLRead(dec); err != nil {
				return err
			}
		case "A2":
			if err := __VDLReadAnon_list_4(dec, &x.A2); err != nil {
				return err
			}
		case "A3":
			if err := __VDLReadAnon_map_5(dec, &x.A3); err != nil {
				return err
			}
		case "A4":
			if err := __VDLReadAnon_map_6(dec, &x.A4); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLReadAnon_list_4(dec vdl.Decoder, x *[]Composites) error {
	if err := dec.StartValue(__VDLType_list_29); err != nil {
		return err
	}
	if len := dec.LenHint(); len > 0 {
		*x = make([]Composites, 0, len)
	} else {
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		default:
			var elem Composites
			if err := elem.VDLRead(dec); err != nil {
				return err
			}
			*x = append(*x, elem)
		}
	}
}

func __VDLReadAnon_map_5(dec vdl.Decoder, x *map[string]Composites) error {
	if err := dec.StartValue(__VDLType_map_30); err != nil {
		return err
	}
	var tmpMap map[string]Composites
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[string]Composites, len)
	}
	for {
		switch done, key, err := dec.NextEntryValueString(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		default:
			var elem Composites
			if err := elem.VDLRead(dec); err != nil {
				return err
			}
			if tmpMap == nil {
				tmpMap = make(map[string]Composites)
			}
			tmpMap[key] = elem
		}
	}
}

func __VDLReadAnon_map_6(dec vdl.Decoder, x *map[KeyScalars][]map[string]Composites) error {
	if err := dec.StartValue(__VDLType_map_31); err != nil {
		return err
	}
	var tmpMap map[KeyScalars][]map[string]Composites
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(map[KeyScalars][]map[string]Composites, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		default:
			var key KeyScalars
			if err := key.VDLRead(dec); err != nil {
				return err
			}
			var elem []map[string]Composites
			if err := __VDLReadAnon_list_7(dec, &elem); err != nil {
				return err
			}
			if tmpMap == nil {
				tmpMap = make(map[KeyScalars][]map[string]Composites)
			}
			tmpMap[key] = elem
		}
	}
}

func __VDLReadAnon_list_7(dec vdl.Decoder, x *[]map[string]Composites) error {
	if err := dec.StartValue(__VDLType_list_32); err != nil {
		return err
	}
	if len := dec.LenHint(); len > 0 {
		*x = make([]map[string]Composites, 0, len)
	} else {
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		default:
			var elem map[string]Composites
			if err := __VDLReadAnon_map_5(dec, &elem); err != nil {
				return err
			}
			*x = append(*x, elem)
		}
	}
}

// Args will be reordered to show up before NestedArgs in the generated output.
type Args struct {
	A int32
	B int32
}

func (Args) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.Args"`
}) {
}

func (x Args) VDLIsZero() bool {
	return x == Args{}
}

func (x Args) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_33); err != nil {
		return err
	}
	if x.A != 0 {
		if err := enc.NextFieldValueInt("A", vdl.Int32Type, int64(x.A)); err != nil {
			return err
		}
	}
	if x.B != 0 {
		if err := enc.NextFieldValueInt("B", vdl.Int32Type, int64(x.B)); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *Args) VDLRead(dec vdl.Decoder) error {
	*x = Args{}
	if err := dec.StartValue(__VDLType_struct_33); err != nil {
		return err
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "A":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.A = int32(value)
			}
		case "B":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.B = int32(value)
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

// NestedArgs is defined before Args; that's allowed in regular Go, and also
// allowed in our vdl files.  The compiler will re-order dependent types to ease
// code generation in other languages.
type NestedArgs struct {
	Args Args
}

func (NestedArgs) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/vdl/testdata/base.NestedArgs"`
}) {
}

func (x NestedArgs) VDLIsZero() bool {
	return x == NestedArgs{}
}

func (x NestedArgs) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_34); err != nil {
		return err
	}
	if x.Args != (Args{}) {
		if err := enc.NextField("Args"); err != nil {
			return err
		}
		if err := x.Args.VDLWrite(enc); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *NestedArgs) VDLRead(dec vdl.Decoder) error {
	*x = NestedArgs{}
	if err := dec.StartValue(__VDLType_struct_34); err != nil {
		return err
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "Args":
			if err := x.Args.VDLRead(dec); err != nil {
				return err
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

//////////////////////////////////////////////////
// Const definitions

const Cbool = true
const Cbyte = byte(1)
const Cint32 = int32(2)
const Cint64 = int64(3)
const Cuint32 = uint32(4)
const Cuint64 = uint64(5)
const Cfloat32 = float32(6)
const Cfloat64 = float64(7)
const CNamedBool = NamedBool(true)

var CNamedStruct = NamedStruct{
	A: true,
	B: "test",
}

const Cstring = "foo"
const Cenum = NamedEnumA

var Cunion = NamedUnion(NamedUnionA{true})
var Carray = NamedArray{
	true,
	false,
}
var Clist = []int32{
	1,
	2,
	3,
}
var Cset = map[int32]struct{}{
	1: struct{}{},
	2: struct{}{},
	3: struct{}{},
}
var cmap = map[int32]string{
	1: "A",
	2: "B",
	3: "C",
}
var Cargs = Args{
	A: 1,
	B: 2,
}
var CScalars = Scalars{
	A0:  true,
	A1:  1,
	A2:  2,
	A3:  3,
	A4:  4,
	A5:  5,
	A6:  6,
	A7:  7,
	A8:  8,
	A9:  9,
	A10: 10,
	A11: "abc",
	A13: vom.RawBytesOf(false),
	A14: vdl.BoolType,
	B0:  true,
	B1:  1,
	B2:  2,
	B3:  3,
	B4:  4,
	B5:  5,
	B6:  6,
	B7:  7,
	B8:  8,
	B9:  9,
	B10: 10,
	B11: "abc",
	B12: NamedEnumB,
	B13: NamedUnionC{123},
}

const True = true
const Foo = "foo"
const Five = int32(5)
const Six = uint64(6)
const SixSquared = uint64(36)
const FiveSquared = int32(25)

var CTypeObject_bool = vdl.BoolType
var CTypeObject_string = vdl.StringType
var CTypeObject_bytes = __VDLType_list_35
var CTypeObject_byte = vdl.ByteType
var CTypeObject_uint16 = vdl.Uint16Type
var CTypeObject_int8 = vdl.Int8Type
var CTypeObject_int16 = vdl.Int16Type
var CTypeObject_float32 = vdl.Float32Type
var CTypeObject_enum = __VDLType_enum_13
var CTypeObject_Array = __VDLType_array_14
var CTypeObject_List = __VDLType_list_36
var CTypeObject_Set = __VDLType_set_37
var CTypeObject_Map = __VDLType_map_38
var CTypeObject_Struct = __VDLType_struct_20
var CTypeObject_Union = __VDLType_union_19
var CTypeObject_TypeObject = vdl.TypeObjectType
var CTypeObject_Any = vdl.AnyType

//////////////////////////////////////////////////
// Error definitions

var (
	ErrNoParams1   = verror.Register("v.io/x/ref/lib/vdl/testdata/base.NoParams1", verror.NoRetry, "{1:}{2:} en msg")
	ErrNoParams2   = verror.Register("v.io/x/ref/lib/vdl/testdata/base.NoParams2", verror.RetryRefetch, "{1:}{2:} en msg")
	ErrWithParams1 = verror.Register("v.io/x/ref/lib/vdl/testdata/base.WithParams1", verror.NoRetry, "{1:}{2:} en x={3} y={4}")
	ErrWithParams2 = verror.Register("v.io/x/ref/lib/vdl/testdata/base.WithParams2", verror.RetryRefetch, "{1:}{2:} en x={3} y={4}")
	errNotExported = verror.Register("v.io/x/ref/lib/vdl/testdata/base.notExported", verror.NoRetry, "{1:}{2:} en x={3} y={4}")
)

// NewErrNoParams1 returns an error with the ErrNoParams1 ID.
func NewErrNoParams1(ctx *context.T) error {
	return verror.New(ErrNoParams1, ctx)
}

// NewErrNoParams2 returns an error with the ErrNoParams2 ID.
func NewErrNoParams2(ctx *context.T) error {
	return verror.New(ErrNoParams2, ctx)
}

// NewErrWithParams1 returns an error with the ErrWithParams1 ID.
func NewErrWithParams1(ctx *context.T, x string, y int32) error {
	return verror.New(ErrWithParams1, ctx, x, y)
}

// NewErrWithParams2 returns an error with the ErrWithParams2 ID.
func NewErrWithParams2(ctx *context.T, x string, y int32) error {
	return verror.New(ErrWithParams2, ctx, x, y)
}

// newErrNotExported returns an error with the errNotExported ID.
func newErrNotExported(ctx *context.T, x string, y int32) error {
	return verror.New(errNotExported, ctx, x, y)
}

//////////////////////////////////////////////////
// Interface definitions

// ServiceAClientMethods is the client interface
// containing ServiceA methods.
type ServiceAClientMethods interface {
	MethodA1(*context.T, ...rpc.CallOpt) error
	MethodA2(_ *context.T, a int32, b string, _ ...rpc.CallOpt) (s string, _ error)
	MethodA3(_ *context.T, a int32, _ ...rpc.CallOpt) (ServiceAMethodA3ClientCall, error)
	MethodA4(_ *context.T, a int32, _ ...rpc.CallOpt) (ServiceAMethodA4ClientCall, error)
}

// ServiceAClientStub adds universal methods to ServiceAClientMethods.
type ServiceAClientStub interface {
	ServiceAClientMethods
	rpc.UniversalServiceMethods
}

// ServiceAClient returns a client stub for ServiceA.
func ServiceAClient(name string) ServiceAClientStub {
	return implServiceAClientStub{name}
}

type implServiceAClientStub struct {
	name string
}

func (c implServiceAClientStub) MethodA1(ctx *context.T, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "MethodA1", nil, nil, opts...)
	return
}

func (c implServiceAClientStub) MethodA2(ctx *context.T, i0 int32, i1 string, opts ...rpc.CallOpt) (o0 string, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "MethodA2", []interface{}{i0, i1}, []interface{}{&o0}, opts...)
	return
}

func (c implServiceAClientStub) MethodA3(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (ocall ServiceAMethodA3ClientCall, err error) {
	var call rpc.ClientCall
	if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "MethodA3", []interface{}{i0}, opts...); err != nil {
		return
	}
	ocall = &implServiceAMethodA3ClientCall{ClientCall: call}
	return
}

func (c implServiceAClientStub) MethodA4(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (ocall ServiceAMethodA4ClientCall, err error) {
	var call rpc.ClientCall
	if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "MethodA4", []interface{}{i0}, opts...); err != nil {
		return
	}
	ocall = &implServiceAMethodA4ClientCall{ClientCall: call}
	return
}

// ServiceAMethodA3ClientStream is the client stream for ServiceA.MethodA3.
type ServiceAMethodA3ClientStream interface {
	// RecvStream returns the receiver side of the ServiceA.MethodA3 client stream.
	RecvStream() interface {
		// Advance stages an item so that it may be retrieved via Value.  Returns
		// true iff there is an item to retrieve.  Advance must be called before
		// Value is called.  May block if an item is not available.
		Advance() bool
		// Value returns the item that was staged by Advance.  May panic if Advance
		// returned false or was not called.  Never blocks.
		Value() Scalars
		// Err returns any error encountered by Advance.  Never blocks.
		Err() error
	}
}

// ServiceAMethodA3ClientCall represents the call returned from ServiceA.MethodA3.
type ServiceAMethodA3ClientCall interface {
	ServiceAMethodA3ClientStream
	// Finish blocks until the server is done, and returns the positional return
	// values for call.
	//
	// Finish returns immediately if the call has been canceled; depending on the
	// timing the output could either be an error signaling cancelation, or the
	// valid positional return values from the server.
	//
	// Calling Finish is mandatory for releasing stream resources, unless the call
	// has been canceled or any of the other methods return an error.  Finish should
	// be called at most once.
	Finish() (s string, _ error)
}

type implServiceAMethodA3ClientCall struct {
	rpc.ClientCall
	valRecv Scalars
	errRecv error
}

func (c *implServiceAMethodA3ClientCall) RecvStream() interface {
	Advance() bool
	Value() Scalars
	Err() error
} {
	return implServiceAMethodA3ClientCallRecv{c}
}

type implServiceAMethodA3ClientCallRecv struct {
	c *implServiceAMethodA3ClientCall
}

func (c implServiceAMethodA3ClientCallRecv) Advance() bool {
	c.c.valRecv = Scalars{}
	c.c.errRecv = c.c.Recv(&c.c.valRecv)
	return c.c.errRecv == nil
}
func (c implServiceAMethodA3ClientCallRecv) Value() Scalars {
	return c.c.valRecv
}
func (c implServiceAMethodA3ClientCallRecv) Err() error {
	if c.c.errRecv == io.EOF {
		return nil
	}
	return c.c.errRecv
}
func (c *implServiceAMethodA3ClientCall) Finish() (o0 string, err error) {
	err = c.ClientCall.Finish(&o0)
	return
}

// ServiceAMethodA4ClientStream is the client stream for ServiceA.MethodA4.
type ServiceAMethodA4ClientStream interface {
	// RecvStream returns the receiver side of the ServiceA.MethodA4 client stream.
	RecvStream() interface {
		// Advance stages an item so that it may be retrieved via Value.  Returns
		// true iff there is an item to retrieve.  Advance must be called before
		// Value is called.  May block if an item is not available.
		Advance() bool
		// Value returns the item that was staged by Advance.  May panic if Advance
		// returned false or was not called.  Never blocks.
		Value() string
		// Err returns any error encountered by Advance.  Never blocks.
		Err() error
	}
	// SendStream returns the send side of the ServiceA.MethodA4 client stream.
	SendStream() interface {
		// Send places the item onto the output stream.  Returns errors
		// encountered while sending, or if Send is called after Close or
		// the stream has been canceled.  Blocks if there is no buffer
		// space; will unblock when buffer space is available or after
		// the stream has been canceled.
		Send(item int32) error
		// Close indicates to the server that no more items will be sent;
		// server Recv calls will receive io.EOF after all sent items.
		// This is an optional call - e.g. a client might call Close if it
		// needs to continue receiving items from the server after it's
		// done sending.  Returns errors encountered while closing, or if
		// Close is called after the stream has been canceled.  Like Send,
		// blocks if there is no buffer space available.
		Close() error
	}
}

// ServiceAMethodA4ClientCall represents the call returned from ServiceA.MethodA4.
type ServiceAMethodA4ClientCall interface {
	ServiceAMethodA4ClientStream
	// Finish performs the equivalent of SendStream().Close, then blocks until
	// the server is done, and returns the positional return values for the call.
	//
	// Finish returns immediately if the call has been canceled; depending on the
	// timing the output could either be an error signaling cancelation, or the
	// valid positional return values from the server.
	//
	// Calling Finish is mandatory for releasing stream resources, unless the call
	// has been canceled or any of the other methods return an error.  Finish should
	// be called at most once.
	Finish() error
}

type implServiceAMethodA4ClientCall struct {
	rpc.ClientCall
	valRecv string
	errRecv error
}

func (c *implServiceAMethodA4ClientCall) RecvStream() interface {
	Advance() bool
	Value() string
	Err() error
} {
	return implServiceAMethodA4ClientCallRecv{c}
}

type implServiceAMethodA4ClientCallRecv struct {
	c *implServiceAMethodA4ClientCall
}

func (c implServiceAMethodA4ClientCallRecv) Advance() bool {
	c.c.errRecv = c.c.Recv(&c.c.valRecv)
	return c.c.errRecv == nil
}
func (c implServiceAMethodA4ClientCallRecv) Value() string {
	return c.c.valRecv
}
func (c implServiceAMethodA4ClientCallRecv) Err() error {
	if c.c.errRecv == io.EOF {
		return nil
	}
	return c.c.errRecv
}
func (c *implServiceAMethodA4ClientCall) SendStream() interface {
	Send(item int32) error
	Close() error
} {
	return implServiceAMethodA4ClientCallSend{c}
}

type implServiceAMethodA4ClientCallSend struct {
	c *implServiceAMethodA4ClientCall
}

func (c implServiceAMethodA4ClientCallSend) Send(item int32) error {
	return c.c.Send(item)
}
func (c implServiceAMethodA4ClientCallSend) Close() error {
	return c.c.CloseSend()
}
func (c *implServiceAMethodA4ClientCall) Finish() (err error) {
	err = c.ClientCall.Finish()
	return
}

// ServiceAServerMethods is the interface a server writer
// implements for ServiceA.
type ServiceAServerMethods interface {
	MethodA1(*context.T, rpc.ServerCall) error
	MethodA2(_ *context.T, _ rpc.ServerCall, a int32, b string) (s string, _ error)
	MethodA3(_ *context.T, _ ServiceAMethodA3ServerCall, a int32) (s string, _ error)
	MethodA4(_ *context.T, _ ServiceAMethodA4ServerCall, a int32) error
}

// ServiceAServerStubMethods is the server interface containing
// ServiceA methods, as expected by rpc.Server.
// The only difference between this interface and ServiceAServerMethods
// is the streaming methods.
type ServiceAServerStubMethods interface {
	MethodA1(*context.T, rpc.ServerCall) error
	MethodA2(_ *context.T, _ rpc.ServerCall, a int32, b string) (s string, _ error)
	MethodA3(_ *context.T, _ *ServiceAMethodA3ServerCallStub, a int32) (s string, _ error)
	MethodA4(_ *context.T, _ *ServiceAMethodA4ServerCallStub, a int32) error
}

// ServiceAServerStub adds universal methods to ServiceAServerStubMethods.
type ServiceAServerStub interface {
	ServiceAServerStubMethods
	// Describe the ServiceA interfaces.
	Describe__() []rpc.InterfaceDesc
}

// ServiceAServer returns a server stub for ServiceA.
// It converts an implementation of ServiceAServerMethods into
// an object that may be used by rpc.Server.
func ServiceAServer(impl ServiceAServerMethods) ServiceAServerStub {
	stub := implServiceAServerStub{
		impl: impl,
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
		stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
		stub.gs = gs
	}
	return stub
}

type implServiceAServerStub struct {
	impl ServiceAServerMethods
	gs   *rpc.GlobState
}

func (s implServiceAServerStub) MethodA1(ctx *context.T, call rpc.ServerCall) error {
	return s.impl.MethodA1(ctx, call)
}

func (s implServiceAServerStub) MethodA2(ctx *context.T, call rpc.ServerCall, i0 int32, i1 string) (string, error) {
	return s.impl.MethodA2(ctx, call, i0, i1)
}

func (s implServiceAServerStub) MethodA3(ctx *context.T, call *ServiceAMethodA3ServerCallStub, i0 int32) (string, error) {
	return s.impl.MethodA3(ctx, call, i0)
}

func (s implServiceAServerStub) MethodA4(ctx *context.T, call *ServiceAMethodA4ServerCallStub, i0 int32) error {
	return s.impl.MethodA4(ctx, call, i0)
}

func (s implServiceAServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implServiceAServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{ServiceADesc}
}

// ServiceADesc describes the ServiceA interface.
var ServiceADesc rpc.InterfaceDesc = descServiceA

// descServiceA hides the desc to keep godoc clean.
var descServiceA = rpc.InterfaceDesc{
	Name:    "ServiceA",
	PkgPath: "v.io/x/ref/lib/vdl/testdata/base",
	Methods: []rpc.MethodDesc{
		{
			Name: "MethodA1",
		},
		{
			Name: "MethodA2",
			InArgs: []rpc.ArgDesc{
				{"a", ``}, // int32
				{"b", ``}, // string
			},
			OutArgs: []rpc.ArgDesc{
				{"s", ``}, // string
			},
		},
		{
			Name: "MethodA3",
			InArgs: []rpc.ArgDesc{
				{"a", ``}, // int32
			},
			OutArgs: []rpc.ArgDesc{
				{"s", ``}, // string
			},
			Tags: []*vdl.Value{vdl.ValueOf("tag"), vdl.ValueOf(uint64(6))},
		},
		{
			Name: "MethodA4",
			InArgs: []rpc.ArgDesc{
				{"a", ``}, // int32
			},
		},
	},
}

// ServiceAMethodA3ServerStream is the server stream for ServiceA.MethodA3.
type ServiceAMethodA3ServerStream interface {
	// SendStream returns the send side of the ServiceA.MethodA3 server stream.
	SendStream() interface {
		// Send places the item onto the output stream.  Returns errors encountered
		// while sending.  Blocks if there is no buffer space; will unblock when
		// buffer space is available.
		Send(item Scalars) error
	}
}

// ServiceAMethodA3ServerCall represents the context passed to ServiceA.MethodA3.
type ServiceAMethodA3ServerCall interface {
	rpc.ServerCall
	ServiceAMethodA3ServerStream
}

// ServiceAMethodA3ServerCallStub is a wrapper that converts rpc.StreamServerCall into
// a typesafe stub that implements ServiceAMethodA3ServerCall.
type ServiceAMethodA3ServerCallStub struct {
	rpc.StreamServerCall
}

// Init initializes ServiceAMethodA3ServerCallStub from rpc.StreamServerCall.
func (s *ServiceAMethodA3ServerCallStub) Init(call rpc.StreamServerCall) {
	s.StreamServerCall = call
}

// SendStream returns the send side of the ServiceA.MethodA3 server stream.
func (s *ServiceAMethodA3ServerCallStub) SendStream() interface {
	Send(item Scalars) error
} {
	return implServiceAMethodA3ServerCallSend{s}
}

type implServiceAMethodA3ServerCallSend struct {
	s *ServiceAMethodA3ServerCallStub
}

func (s implServiceAMethodA3ServerCallSend) Send(item Scalars) error {
	return s.s.Send(item)
}

// ServiceAMethodA4ServerStream is the server stream for ServiceA.MethodA4.
type ServiceAMethodA4ServerStream interface {
	// RecvStream returns the receiver side of the ServiceA.MethodA4 server stream.
	RecvStream() interface {
		// Advance stages an item so that it may be retrieved via Value.  Returns
		// true iff there is an item to retrieve.  Advance must be called before
		// Value is called.  May block if an item is not available.
		Advance() bool
		// Value returns the item that was staged by Advance.  May panic if Advance
		// returned false or was not called.  Never blocks.
		Value() int32
		// Err returns any error encountered by Advance.  Never blocks.
		Err() error
	}
	// SendStream returns the send side of the ServiceA.MethodA4 server stream.
	SendStream() interface {
		// Send places the item onto the output stream.  Returns errors encountered
		// while sending.  Blocks if there is no buffer space; will unblock when
		// buffer space is available.
		Send(item string) error
	}
}

// ServiceAMethodA4ServerCall represents the context passed to ServiceA.MethodA4.
type ServiceAMethodA4ServerCall interface {
	rpc.ServerCall
	ServiceAMethodA4ServerStream
}

// ServiceAMethodA4ServerCallStub is a wrapper that converts rpc.StreamServerCall into
// a typesafe stub that implements ServiceAMethodA4ServerCall.
type ServiceAMethodA4ServerCallStub struct {
	rpc.StreamServerCall
	valRecv int32
	errRecv error
}

// Init initializes ServiceAMethodA4ServerCallStub from rpc.StreamServerCall.
func (s *ServiceAMethodA4ServerCallStub) Init(call rpc.StreamServerCall) {
	s.StreamServerCall = call
}

// RecvStream returns the receiver side of the ServiceA.MethodA4 server stream.
func (s *ServiceAMethodA4ServerCallStub) RecvStream() interface {
	Advance() bool
	Value() int32
	Err() error
} {
	return implServiceAMethodA4ServerCallRecv{s}
}

type implServiceAMethodA4ServerCallRecv struct {
	s *ServiceAMethodA4ServerCallStub
}

func (s implServiceAMethodA4ServerCallRecv) Advance() bool {
	s.s.errRecv = s.s.Recv(&s.s.valRecv)
	return s.s.errRecv == nil
}
func (s implServiceAMethodA4ServerCallRecv) Value() int32 {
	return s.s.valRecv
}
func (s implServiceAMethodA4ServerCallRecv) Err() error {
	if s.s.errRecv == io.EOF {
		return nil
	}
	return s.s.errRecv
}

// SendStream returns the send side of the ServiceA.MethodA4 server stream.
func (s *ServiceAMethodA4ServerCallStub) SendStream() interface {
	Send(item string) error
} {
	return implServiceAMethodA4ServerCallSend{s}
}

type implServiceAMethodA4ServerCallSend struct {
	s *ServiceAMethodA4ServerCallStub
}

func (s implServiceAMethodA4ServerCallSend) Send(item string) error {
	return s.s.Send(item)
}

// ServiceBClientMethods is the client interface
// containing ServiceB methods.
type ServiceBClientMethods interface {
	ServiceAClientMethods
	MethodB1(_ *context.T, a Scalars, b Composites, _ ...rpc.CallOpt) (c CompComp, _ error)
}

// ServiceBClientStub adds universal methods to ServiceBClientMethods.
type ServiceBClientStub interface {
	ServiceBClientMethods
	rpc.UniversalServiceMethods
}

// ServiceBClient returns a client stub for ServiceB.
func ServiceBClient(name string) ServiceBClientStub {
	return implServiceBClientStub{name, ServiceAClient(name)}
}

type implServiceBClientStub struct {
	name string

	ServiceAClientStub
}

func (c implServiceBClientStub) MethodB1(ctx *context.T, i0 Scalars, i1 Composites, opts ...rpc.CallOpt) (o0 CompComp, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "MethodB1", []interface{}{i0, i1}, []interface{}{&o0}, opts...)
	return
}

// ServiceBServerMethods is the interface a server writer
// implements for ServiceB.
type ServiceBServerMethods interface {
	ServiceAServerMethods
	MethodB1(_ *context.T, _ rpc.ServerCall, a Scalars, b Composites) (c CompComp, _ error)
}

// ServiceBServerStubMethods is the server interface containing
// ServiceB methods, as expected by rpc.Server.
// The only difference between this interface and ServiceBServerMethods
// is the streaming methods.
type ServiceBServerStubMethods interface {
	ServiceAServerStubMethods
	MethodB1(_ *context.T, _ rpc.ServerCall, a Scalars, b Composites) (c CompComp, _ error)
}

// ServiceBServerStub adds universal methods to ServiceBServerStubMethods.
type ServiceBServerStub interface {
	ServiceBServerStubMethods
	// Describe the ServiceB interfaces.
	Describe__() []rpc.InterfaceDesc
}

// ServiceBServer returns a server stub for ServiceB.
// It converts an implementation of ServiceBServerMethods into
// an object that may be used by rpc.Server.
func ServiceBServer(impl ServiceBServerMethods) ServiceBServerStub {
	stub := implServiceBServerStub{
		impl:               impl,
		ServiceAServerStub: ServiceAServer(impl),
	}
	// Initialize GlobState; always check the stub itself first, to handle the
	// case where the user has the Glob method defined in their VDL source.
	if gs := rpc.NewGlobState(stub); gs != nil {
		stub.gs = gs
	} else if gs := rpc.NewGlobState(impl); gs != nil {
		stub.gs = gs
	}
	return stub
}

type implServiceBServerStub struct {
	impl ServiceBServerMethods
	ServiceAServerStub
	gs *rpc.GlobState
}

func (s implServiceBServerStub) MethodB1(ctx *context.T, call rpc.ServerCall, i0 Scalars, i1 Composites) (CompComp, error) {
	return s.impl.MethodB1(ctx, call, i0, i1)
}

func (s implServiceBServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implServiceBServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{ServiceBDesc, ServiceADesc}
}

// ServiceBDesc describes the ServiceB interface.
var ServiceBDesc rpc.InterfaceDesc = descServiceB

// descServiceB hides the desc to keep godoc clean.
var descServiceB = rpc.InterfaceDesc{
	Name:    "ServiceB",
	PkgPath: "v.io/x/ref/lib/vdl/testdata/base",
	Embeds: []rpc.EmbedDesc{
		{"ServiceA", "v.io/x/ref/lib/vdl/testdata/base", ``},
	},
	Methods: []rpc.MethodDesc{
		{
			Name: "MethodB1",
			InArgs: []rpc.ArgDesc{
				{"a", ``}, // Scalars
				{"b", ``}, // Composites
			},
			OutArgs: []rpc.ArgDesc{
				{"c", ``}, // CompComp
			},
		},
	},
}

// Hold type definitions in package-level variables, for better performance.
var (
	__VDLType_bool_1     *vdl.Type
	__VDLType_byte_2     *vdl.Type
	__VDLType_uint16_3   *vdl.Type
	__VDLType_uint32_4   *vdl.Type
	__VDLType_uint64_5   *vdl.Type
	__VDLType_int8_6     *vdl.Type
	__VDLType_int16_7    *vdl.Type
	__VDLType_int32_8    *vdl.Type
	__VDLType_int64_9    *vdl.Type
	__VDLType_float32_10 *vdl.Type
	__VDLType_float64_11 *vdl.Type
	__VDLType_string_12  *vdl.Type
	__VDLType_enum_13    *vdl.Type
	__VDLType_array_14   *vdl.Type
	__VDLType_list_15    *vdl.Type
	__VDLType_set_16     *vdl.Type
	__VDLType_map_17     *vdl.Type
	__VDLType_struct_18  *vdl.Type
	__VDLType_union_19   *vdl.Type
	__VDLType_struct_20  *vdl.Type
	__VDLType_struct_21  *vdl.Type
	__VDLType_array_22   *vdl.Type
	__VDLType_struct_23  *vdl.Type
	__VDLType_list_24    *vdl.Type
	__VDLType_set_25     *vdl.Type
	__VDLType_map_26     *vdl.Type
	__VDLType_array_27   *vdl.Type
	__VDLType_struct_28  *vdl.Type
	__VDLType_list_29    *vdl.Type
	__VDLType_map_30     *vdl.Type
	__VDLType_map_31     *vdl.Type
	__VDLType_list_32    *vdl.Type
	__VDLType_struct_33  *vdl.Type
	__VDLType_struct_34  *vdl.Type
	__VDLType_list_35    *vdl.Type
	__VDLType_list_36    *vdl.Type
	__VDLType_set_37     *vdl.Type
	__VDLType_map_38     *vdl.Type
)

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{}{}
	}
	__VDLInitCalled = true

	// Register types.
	vdl.Register((*NamedBool)(nil))
	vdl.Register((*NamedByte)(nil))
	vdl.Register((*NamedUint16)(nil))
	vdl.Register((*NamedUint32)(nil))
	vdl.Register((*NamedUint64)(nil))
	vdl.Register((*NamedInt8)(nil))
	vdl.Register((*NamedInt16)(nil))
	vdl.Register((*NamedInt32)(nil))
	vdl.Register((*NamedInt64)(nil))
	vdl.Register((*NamedFloat32)(nil))
	vdl.Register((*NamedFloat64)(nil))
	vdl.Register((*NamedString)(nil))
	vdl.Register((*NamedEnum)(nil))
	vdl.Register((*NamedArray)(nil))
	vdl.Register((*NamedList)(nil))
	vdl.Register((*NamedSet)(nil))
	vdl.Register((*NamedMap)(nil))
	vdl.Register((*NamedStruct)(nil))
	vdl.Register((*NamedUnion)(nil))
	vdl.Register((*Scalars)(nil))
	vdl.Register((*KeyScalars)(nil))
	vdl.Register((*ScalarsArray)(nil))
	vdl.Register((*Composites)(nil))
	vdl.Register((*CompositesArray)(nil))
	vdl.Register((*CompComp)(nil))
	vdl.Register((*Args)(nil))
	vdl.Register((*NestedArgs)(nil))

	// Initialize type definitions.
	__VDLType_bool_1 = vdl.TypeOf((*NamedBool)(nil))
	__VDLType_byte_2 = vdl.TypeOf((*NamedByte)(nil))
	__VDLType_uint16_3 = vdl.TypeOf((*NamedUint16)(nil))
	__VDLType_uint32_4 = vdl.TypeOf((*NamedUint32)(nil))
	__VDLType_uint64_5 = vdl.TypeOf((*NamedUint64)(nil))
	__VDLType_int8_6 = vdl.TypeOf((*NamedInt8)(nil))
	__VDLType_int16_7 = vdl.TypeOf((*NamedInt16)(nil))
	__VDLType_int32_8 = vdl.TypeOf((*NamedInt32)(nil))
	__VDLType_int64_9 = vdl.TypeOf((*NamedInt64)(nil))
	__VDLType_float32_10 = vdl.TypeOf((*NamedFloat32)(nil))
	__VDLType_float64_11 = vdl.TypeOf((*NamedFloat64)(nil))
	__VDLType_string_12 = vdl.TypeOf((*NamedString)(nil))
	__VDLType_enum_13 = vdl.TypeOf((*NamedEnum)(nil))
	__VDLType_array_14 = vdl.TypeOf((*NamedArray)(nil))
	__VDLType_list_15 = vdl.TypeOf((*NamedList)(nil))
	__VDLType_set_16 = vdl.TypeOf((*NamedSet)(nil))
	__VDLType_map_17 = vdl.TypeOf((*NamedMap)(nil))
	__VDLType_struct_18 = vdl.TypeOf((*NamedStruct)(nil)).Elem()
	__VDLType_union_19 = vdl.TypeOf((*NamedUnion)(nil))
	__VDLType_struct_20 = vdl.TypeOf((*Scalars)(nil)).Elem()
	__VDLType_struct_21 = vdl.TypeOf((*KeyScalars)(nil)).Elem()
	__VDLType_array_22 = vdl.TypeOf((*ScalarsArray)(nil))
	__VDLType_struct_23 = vdl.TypeOf((*Composites)(nil)).Elem()
	__VDLType_list_24 = vdl.TypeOf((*[]Scalars)(nil))
	__VDLType_set_25 = vdl.TypeOf((*map[KeyScalars]struct{})(nil))
	__VDLType_map_26 = vdl.TypeOf((*map[string]Scalars)(nil))
	__VDLType_array_27 = vdl.TypeOf((*CompositesArray)(nil))
	__VDLType_struct_28 = vdl.TypeOf((*CompComp)(nil)).Elem()
	__VDLType_list_29 = vdl.TypeOf((*[]Composites)(nil))
	__VDLType_map_30 = vdl.TypeOf((*map[string]Composites)(nil))
	__VDLType_map_31 = vdl.TypeOf((*map[KeyScalars][]map[string]Composites)(nil))
	__VDLType_list_32 = vdl.TypeOf((*[]map[string]Composites)(nil))
	__VDLType_struct_33 = vdl.TypeOf((*Args)(nil)).Elem()
	__VDLType_struct_34 = vdl.TypeOf((*NestedArgs)(nil)).Elem()
	__VDLType_list_35 = vdl.TypeOf((*[]byte)(nil))
	__VDLType_list_36 = vdl.TypeOf((*[]string)(nil))
	__VDLType_set_37 = vdl.TypeOf((*map[string]struct{})(nil))
	__VDLType_map_38 = vdl.TypeOf((*map[string]int64)(nil))

	// Set error format strings.
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrNoParams1.ID), "{1:}{2:} en msg")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrNoParams2.ID), "{1:}{2:} en msg")
	i18n.Cat().SetWithBase(i18n.LangID("fr"), i18n.MsgID(ErrNoParams2.ID), "{1:}{2:} fr msg")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrWithParams1.ID), "{1:}{2:} en x={3} y={4}")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrWithParams2.ID), "{1:}{2:} en x={3} y={4}")
	i18n.Cat().SetWithBase(i18n.LangID("fr"), i18n.MsgID(ErrWithParams2.ID), "{1:}{2:} fr y={4} x={3}")
	i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(errNotExported.ID), "{1:}{2:} en x={3} y={4}")

	return struct{}{}
}