diff --git a/Makefile b/Makefile
index 01d1a15..4c644f4 100644
--- a/Makefile
+++ b/Makefile
@@ -129,14 +129,29 @@
 $(BUILD_DIR)/echo_server.mojo: gen/go/src/mojom/examples/echo/echo.mojom.go
 	$(call MOGO_BUILD,examples/echo/server,$@)
 
-.PHONY: test-integration
-test-integration: mock packages $(BUILD_DIR)/test_client.mojo $(BUILD_DIR)/test_server.mojo $(BUILD_DIR)/v23clientproxy.mojo $(BUILD_DIR)/v23serverproxy.mojo
-	GOPATH=$(PWD)/go:$(PWD)/gen/go jiri go -profiles=v23:base,$(MOJO_PROFILE) run go/src/v.io/x/mojo/tests/cmd/runtest.go || ($(MAKE) unmock && exit 1)
-	GOPATH=$(PWD)/go:$(PWD)/gen/go jiri go -profiles=v23:base,v23:dart,$(MOJO_PROFILE) run go/src/v.io/x/mojo/tests/cmd/runtest.go -client dart || ($(MAKE) unmock && exit 1)
-	GOPATH=$(PWD)/go:$(PWD)/gen/go jiri go -profiles=v23:base,v23:dart,$(MOJO_PROFILE) run go/src/v.io/x/mojo/tests/cmd/runtest.go -server dart || ($(MAKE) unmock && exit 1)
-	GOPATH=$(PWD)/go:$(PWD)/gen/go jiri go -profiles=v23:base,v23:dart,$(MOJO_PROFILE) run go/src/v.io/x/mojo/tests/cmd/runtest.go -client dart -server dart || ($(MAKE) unmock && exit 1)
+.PHONY: test-integration-depends
+test-integration-depends: mock packages $(BUILD_DIR)/test_client.mojo $(BUILD_DIR)/test_server.mojo $(BUILD_DIR)/v23clientproxy.mojo $(BUILD_DIR)/v23serverproxy.mojo
 	$(MAKE) unmock
 
+.PHONY: test-integration-go-go
+test-integration-go-go: test-integration-depends
+	GOPATH=$(PWD)/go:$(PWD)/gen/go jiri go -profiles=v23:base,$(MOJO_PROFILE) run go/src/v.io/x/mojo/tests/cmd/runtest.go || ($(MAKE) unmock && exit 1)
+
+.PHONY: test-integration-dart-go
+test-integration-dart-go: test-integration-depends
+	GOPATH=$(PWD)/go:$(PWD)/gen/go jiri go -profiles=v23:base,v23:dart,$(MOJO_PROFILE) run go/src/v.io/x/mojo/tests/cmd/runtest.go -client dart || ($(MAKE) unmock && exit 1)
+
+.PHONY: test-integration-go-dart
+test-integration-go-dart: test-integration-depends
+	GOPATH=$(PWD)/go:$(PWD)/gen/go jiri go -profiles=v23:base,v23:dart,$(MOJO_PROFILE) run go/src/v.io/x/mojo/tests/cmd/runtest.go -server dart || ($(MAKE) unmock && exit 1)
+
+.PHONY: test-integration-dart-dart
+test-integration-dart-dart: test-integration-depends
+	GOPATH=$(PWD)/go:$(PWD)/gen/go jiri go -profiles=v23:base,v23:dart,$(MOJO_PROFILE) run go/src/v.io/x/mojo/tests/cmd/runtest.go -client dart -server dart || ($(MAKE) unmock && exit 1)
+
+.PHONY: test-integration
+test-integration: test-integration-go-go test-integration-dart-go test-integration-go-dart test-integration-dart-dart
+
 $(BUILD_DIR)/test_client.mojo: go/src/v.io/x/mojo/tests/client/test_client.go gen/go/src/mojom/tests/end_to_end_test/end_to_end_test.mojom.go dart-tests/end_to_end_test/lib/gen/dart-gen/mojom/lib/mojo/v23proxy/tests/end_to_end_test.mojom.dart gen/go/src/mojom/v23clientproxy/v23clientproxy.mojom.go
 	$(call MOGO_BUILD,v.io/x/mojo/tests/client,$@)
 
diff --git a/go/src/v.io/x/mojo/proxy/util/util.go b/go/src/v.io/x/mojo/proxy/util/util.go
index 7967d9d..889e786 100644
--- a/go/src/v.io/x/mojo/proxy/util/util.go
+++ b/go/src/v.io/x/mojo/proxy/util/util.go
@@ -46,6 +46,21 @@
 	return nil
 }
 
+func (ft *structSplitFieldsTarget) ZeroField(name string) (error) {
+	key, field, err := ft.StartField(name)
+	if err != nil {
+		return err
+	}
+	fld, index := ft.targ.tt.FieldByName(name)
+	if index < 0 {
+		return vdl.ErrFieldNoExist
+	}
+	if err := vdl.FromValue(field, vdl.ZeroValue(fld.Type)); err != nil {
+		return err
+	}
+	return ft.FinishField(key, field)
+}
+
 func StructSplitTarget() *structSplitTarget {
 	return &structSplitTarget{}
 }
diff --git a/go/src/v.io/x/mojo/transcoder/internal/internal.vdl.go b/go/src/v.io/x/mojo/transcoder/internal/internal.vdl.go
index 83fb2a3..8cb994e 100644
--- a/go/src/v.io/x/mojo/transcoder/internal/internal.vdl.go
+++ b/go/src/v.io/x/mojo/transcoder/internal/internal.vdl.go
@@ -185,6 +185,144 @@
 	return nil
 }
 
+func (x AddressInfo) VDLIsZero() bool {
+	return x == AddressInfo{}
+}
+
+func (x AddressInfo) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*AddressInfo)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.Street != "" {
+		if err := enc.NextField("Street"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.StringType); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(x.Street); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.City != "" {
+		if err := enc.NextField("City"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.StringType); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(x.City); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.State != "" {
+		if err := enc.NextField("State"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.StringType); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(x.State); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.Zip != "" {
+		if err := enc.NextField("Zip"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.StringType); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(x.Zip); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *AddressInfo) VDLRead(dec vdl.Decoder) error {
+	*x = AddressInfo{}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "Street":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.Street, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "City":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.City, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "State":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.State, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "Zip":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.Zip, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 type CreditAgency int
 
 const (
@@ -273,6 +411,34 @@
 	return nil
 }
 
+func (x CreditAgency) VDLIsZero() bool {
+	return x == CreditAgencyEquifax
+}
+
+func (x CreditAgency) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*CreditAgency)(nil))); err != nil {
+		return err
+	}
+	if err := enc.EncodeString(x.String()); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *CreditAgency) VDLRead(dec vdl.Decoder) error {
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	enum, err := dec.DecodeString()
+	if err != nil {
+		return err
+	}
+	if err := x.Set(enum); err != nil {
+		return err
+	}
+	return dec.FinishValue()
+}
+
 type ExperianRating int
 
 const (
@@ -353,6 +519,34 @@
 	return nil
 }
 
+func (x ExperianRating) VDLIsZero() bool {
+	return x == ExperianRatingGood
+}
+
+func (x ExperianRating) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*ExperianRating)(nil))); err != nil {
+		return err
+	}
+	if err := enc.EncodeString(x.String()); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *ExperianRating) VDLRead(dec vdl.Decoder) error {
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	enum, err := dec.DecodeString()
+	if err != nil {
+		return err
+	}
+	if err := x.Set(enum); err != nil {
+		return err
+	}
+	return dec.FinishValue()
+}
+
 type EquifaxCreditReport struct {
 	Rating byte
 }
@@ -437,6 +631,70 @@
 	return nil
 }
 
+func (x EquifaxCreditReport) VDLIsZero() bool {
+	return x == EquifaxCreditReport{}
+}
+
+func (x EquifaxCreditReport) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*EquifaxCreditReport)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.Rating != 0 {
+		if err := enc.NextField("Rating"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.ByteType); err != nil {
+			return err
+		}
+		if err := enc.EncodeUint(uint64(x.Rating)); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *EquifaxCreditReport) VDLRead(dec vdl.Decoder) error {
+	*x = EquifaxCreditReport{}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "Rating":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			tmp, err := dec.DecodeUint(8)
+			if err != nil {
+				return err
+			}
+			x.Rating = byte(tmp)
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 type ExperianCreditReport struct {
 	Rating ExperianRating
 }
@@ -522,6 +780,56 @@
 	return nil
 }
 
+func (x ExperianCreditReport) VDLIsZero() bool {
+	return x == ExperianCreditReport{}
+}
+
+func (x ExperianCreditReport) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*ExperianCreditReport)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.Rating != ExperianRatingGood {
+		if err := enc.NextField("Rating"); err != nil {
+			return err
+		}
+		if err := x.Rating.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *ExperianCreditReport) VDLRead(dec vdl.Decoder) error {
+	*x = ExperianCreditReport{}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "Rating":
+			if err := x.Rating.VDLRead(dec); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 type TransUnionCreditReport struct {
 	Rating int16
 }
@@ -606,6 +914,70 @@
 	return nil
 }
 
+func (x TransUnionCreditReport) VDLIsZero() bool {
+	return x == TransUnionCreditReport{}
+}
+
+func (x TransUnionCreditReport) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*TransUnionCreditReport)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.Rating != 0 {
+		if err := enc.NextField("Rating"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int16Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(int64(x.Rating)); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *TransUnionCreditReport) VDLRead(dec vdl.Decoder) error {
+	*x = TransUnionCreditReport{}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "Rating":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			tmp, err := dec.DecodeInt(16)
+			if err != nil {
+				return err
+			}
+			x.Rating = int16(tmp)
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 type (
 	// AgencyReport represents any single field of the AgencyReport union type.
 	AgencyReport interface {
@@ -618,6 +990,8 @@
 		// __VDLReflect describes the AgencyReport union type.
 		__VDLReflect(__AgencyReportReflect)
 		FillVDLTarget(vdl.Target, *vdl.Type) error
+		VDLIsZero() bool
+		VDLWrite(vdl.Encoder) error
 	}
 	// AgencyReportEquifaxReport represents field EquifaxReport of the AgencyReport union type.
 	AgencyReportEquifaxReport struct{ Value EquifaxCreditReport }
@@ -790,6 +1164,110 @@
 	return nil, fmt.Errorf("got %T, want *AgencyReport", union)
 }
 
+func (x AgencyReportEquifaxReport) VDLIsZero() bool {
+	return x.Value == EquifaxCreditReport{}
+}
+
+func (x AgencyReportExperianReport) VDLIsZero() bool {
+	return false
+}
+
+func (x AgencyReportTransUnionReport) VDLIsZero() bool {
+	return false
+}
+
+func (x AgencyReportEquifaxReport) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*AgencyReport)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("EquifaxReport"); err != nil {
+		return err
+	}
+	if err := x.Value.VDLWrite(enc); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x AgencyReportExperianReport) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*AgencyReport)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("ExperianReport"); err != nil {
+		return err
+	}
+	if err := x.Value.VDLWrite(enc); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x AgencyReportTransUnionReport) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*AgencyReport)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("TransUnionReport"); err != nil {
+		return err
+	}
+	if err := x.Value.VDLWrite(enc); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func VDLReadAgencyReport(dec vdl.Decoder, x *AgencyReport) error {
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(x), dec.Type()) {
+		return fmt.Errorf("incompatible union %T, from %v", x, dec.Type())
+	}
+	f, err := dec.NextField()
+	if err != nil {
+		return err
+	}
+	switch f {
+	case "EquifaxReport":
+		var field AgencyReportEquifaxReport
+		if err := field.Value.VDLRead(dec); err != nil {
+			return err
+		}
+		*x = field
+	case "ExperianReport":
+		var field AgencyReportExperianReport
+		if err := field.Value.VDLRead(dec); err != nil {
+			return err
+		}
+		*x = field
+	case "TransUnionReport":
+		var field AgencyReportTransUnionReport
+		if err := field.Value.VDLRead(dec); err != nil {
+			return err
+		}
+		*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 CreditReport struct {
 	Agency CreditAgency
 	Report AgencyReport
@@ -913,6 +1391,76 @@
 	return nil
 }
 
+func (x CreditReport) VDLIsZero() bool {
+	if x.Agency != CreditAgencyEquifax {
+		return false
+	}
+	if x.Report != nil && !x.Report.VDLIsZero() {
+		return false
+	}
+	return true
+}
+
+func (x CreditReport) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*CreditReport)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.Agency != CreditAgencyEquifax {
+		if err := enc.NextField("Agency"); err != nil {
+			return err
+		}
+		if err := x.Agency.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if x.Report != nil && !x.Report.VDLIsZero() {
+		if err := enc.NextField("Report"); err != nil {
+			return err
+		}
+		if err := x.Report.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *CreditReport) VDLRead(dec vdl.Decoder) error {
+	*x = CreditReport{
+		Report: AgencyReportEquifaxReport{},
+	}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "Agency":
+			if err := x.Agency.VDLRead(dec); err != nil {
+				return err
+			}
+		case "Report":
+			if err := VDLReadAgencyReport(dec, &x.Report); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 type Customer struct {
 	Name    string
 	Id      int64
@@ -1115,6 +1663,162 @@
 	return nil
 }
 
+func (x Customer) VDLIsZero() bool {
+	if x.Name != "" {
+		return false
+	}
+	if x.Id != 0 {
+		return false
+	}
+	if x.Active {
+		return false
+	}
+	if x.Address != (AddressInfo{}) {
+		return false
+	}
+	if !x.Credit.VDLIsZero() {
+		return false
+	}
+	return true
+}
+
+func (x Customer) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*Customer)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.Name != "" {
+		if err := enc.NextField("Name"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.StringType); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(x.Name); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.Id != 0 {
+		if err := enc.NextField("Id"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int64Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(x.Id); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.Active {
+		if err := enc.NextField("Active"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.BoolType); err != nil {
+			return err
+		}
+		if err := enc.EncodeBool(x.Active); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.Address != (AddressInfo{}) {
+		if err := enc.NextField("Address"); err != nil {
+			return err
+		}
+		if err := x.Address.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if !x.Credit.VDLIsZero() {
+		if err := enc.NextField("Credit"); err != nil {
+			return err
+		}
+		if err := x.Credit.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *Customer) VDLRead(dec vdl.Decoder) error {
+	*x = Customer{
+		Credit: CreditReport{
+			Report: AgencyReportEquifaxReport{},
+		},
+	}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "Name":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.Name, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "Id":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.Id, err = dec.DecodeInt(64); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "Active":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.Active, err = dec.DecodeBool(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "Address":
+			if err := x.Address.VDLRead(dec); err != nil {
+				return err
+			}
+		case "Credit":
+			if err := x.Credit.VDLRead(dec); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 var __VDLInitCalled bool
 
 // __VDLInit performs vdl initialization.  It is safe to call multiple times.
diff --git a/go/src/v.io/x/mojo/transcoder/testtypes/testtypes.vdl.go b/go/src/v.io/x/mojo/transcoder/testtypes/testtypes.vdl.go
index fae9534..36ea9df 100644
--- a/go/src/v.io/x/mojo/transcoder/testtypes/testtypes.vdl.go
+++ b/go/src/v.io/x/mojo/transcoder/testtypes/testtypes.vdl.go
@@ -97,6 +97,34 @@
 	return nil
 }
 
+func (x AnEnum) VDLIsZero() bool {
+	return x == AnEnumFirst
+}
+
+func (x AnEnum) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*AnEnum)(nil))); err != nil {
+		return err
+	}
+	if err := enc.EncodeString(x.String()); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *AnEnum) VDLRead(dec vdl.Decoder) error {
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	enum, err := dec.DecodeString()
+	if err != nil {
+		return err
+	}
+	if err := x.Set(enum); err != nil {
+		return err
+	}
+	return dec.FinishValue()
+}
+
 type (
 	// PodUnion represents any single field of the PodUnion union type.
 	PodUnion interface {
@@ -109,6 +137,8 @@
 		// __VDLReflect describes the PodUnion union type.
 		__VDLReflect(__PodUnionReflect)
 		FillVDLTarget(vdl.Target, *vdl.Type) error
+		VDLIsZero() bool
+		VDLWrite(vdl.Encoder) error
 	}
 	// PodUnionFInt8 represents field FInt8 of the PodUnion union type.
 	PodUnionFInt8 struct{ Value int8 }
@@ -669,6 +699,534 @@
 	return nil, fmt.Errorf("got %T, want *PodUnion", union)
 }
 
+func (x PodUnionFInt8) VDLIsZero() bool {
+	return x.Value == 0
+}
+
+func (x PodUnionFInt8Other) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFUint8) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFInt16) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFUint16) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFint32) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFuint32) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFInt64) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFUint64) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFFloat) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFDouble) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFBool) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFEnum) VDLIsZero() bool {
+	return false
+}
+
+func (x PodUnionFInt8) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FInt8"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.Int8Type); err != nil {
+		return err
+	}
+	if err := enc.EncodeInt(int64(x.Value)); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFInt8Other) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FInt8Other"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.Int8Type); err != nil {
+		return err
+	}
+	if err := enc.EncodeInt(int64(x.Value)); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFUint8) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FUint8"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.ByteType); err != nil {
+		return err
+	}
+	if err := enc.EncodeUint(uint64(x.Value)); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFInt16) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FInt16"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.Int16Type); err != nil {
+		return err
+	}
+	if err := enc.EncodeInt(int64(x.Value)); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFUint16) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FUint16"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.Uint16Type); err != nil {
+		return err
+	}
+	if err := enc.EncodeUint(uint64(x.Value)); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFint32) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("Fint32"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.Int32Type); err != nil {
+		return err
+	}
+	if err := enc.EncodeInt(int64(x.Value)); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFuint32) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("Fuint32"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.Uint32Type); err != nil {
+		return err
+	}
+	if err := enc.EncodeUint(uint64(x.Value)); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFInt64) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FInt64"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.Int64Type); err != nil {
+		return err
+	}
+	if err := enc.EncodeInt(x.Value); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFUint64) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FUint64"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.Uint64Type); err != nil {
+		return err
+	}
+	if err := enc.EncodeUint(x.Value); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFFloat) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FFloat"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.Float32Type); err != nil {
+		return err
+	}
+	if err := enc.EncodeFloat(float64(x.Value)); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFDouble) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FDouble"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.Float64Type); err != nil {
+		return err
+	}
+	if err := enc.EncodeFloat(x.Value); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFBool) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FBool"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.BoolType); err != nil {
+		return err
+	}
+	if err := enc.EncodeBool(x.Value); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x PodUnionFEnum) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FEnum"); err != nil {
+		return err
+	}
+	if err := x.Value.VDLWrite(enc); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func VDLReadPodUnion(dec vdl.Decoder, x *PodUnion) error {
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(x), dec.Type()) {
+		return fmt.Errorf("incompatible union %T, from %v", x, dec.Type())
+	}
+	f, err := dec.NextField()
+	if err != nil {
+		return err
+	}
+	switch f {
+	case "FInt8":
+		var field PodUnionFInt8
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		tmp, err := dec.DecodeInt(8)
+		if err != nil {
+			return err
+		}
+		field.Value = int8(tmp)
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FInt8Other":
+		var field PodUnionFInt8Other
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		tmp, err := dec.DecodeInt(8)
+		if err != nil {
+			return err
+		}
+		field.Value = int8(tmp)
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FUint8":
+		var field PodUnionFUint8
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		tmp, err := dec.DecodeUint(8)
+		if err != nil {
+			return err
+		}
+		field.Value = byte(tmp)
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FInt16":
+		var field PodUnionFInt16
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		tmp, err := dec.DecodeInt(16)
+		if err != nil {
+			return err
+		}
+		field.Value = int16(tmp)
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FUint16":
+		var field PodUnionFUint16
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		tmp, err := dec.DecodeUint(16)
+		if err != nil {
+			return err
+		}
+		field.Value = uint16(tmp)
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "Fint32":
+		var field PodUnionFint32
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		tmp, err := dec.DecodeInt(32)
+		if err != nil {
+			return err
+		}
+		field.Value = int32(tmp)
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "Fuint32":
+		var field PodUnionFuint32
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		tmp, err := dec.DecodeUint(32)
+		if err != nil {
+			return err
+		}
+		field.Value = uint32(tmp)
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FInt64":
+		var field PodUnionFInt64
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		var err error
+		if field.Value, err = dec.DecodeInt(64); err != nil {
+			return err
+		}
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FUint64":
+		var field PodUnionFUint64
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		var err error
+		if field.Value, err = dec.DecodeUint(64); err != nil {
+			return err
+		}
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FFloat":
+		var field PodUnionFFloat
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		tmp, err := dec.DecodeFloat(32)
+		if err != nil {
+			return err
+		}
+		field.Value = float32(tmp)
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FDouble":
+		var field PodUnionFDouble
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		var err error
+		if field.Value, err = dec.DecodeFloat(64); err != nil {
+			return err
+		}
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FBool":
+		var field PodUnionFBool
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		var err error
+		if field.Value, err = dec.DecodeBool(); err != nil {
+			return err
+		}
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FEnum":
+		var field PodUnionFEnum
+		if err := field.Value.VDLRead(dec); err != nil {
+			return err
+		}
+		*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 PodUnionWrapper struct {
 	PodUnion PodUnion
 }
@@ -763,6 +1321,61 @@
 	return nil
 }
 
+func (x PodUnionWrapper) VDLIsZero() bool {
+	if x.PodUnion != nil && !x.PodUnion.VDLIsZero() {
+		return false
+	}
+	return true
+}
+
+func (x PodUnionWrapper) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*PodUnionWrapper)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.PodUnion != nil && !x.PodUnion.VDLIsZero() {
+		if err := enc.NextField("PodUnion"); err != nil {
+			return err
+		}
+		if err := x.PodUnion.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *PodUnionWrapper) VDLRead(dec vdl.Decoder) error {
+	*x = PodUnionWrapper{
+		PodUnion: PodUnionFInt8{},
+	}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "PodUnion":
+			if err := VDLReadPodUnion(dec, &x.PodUnion); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 type DummyStruct struct {
 	FInt8 int8
 }
@@ -847,6 +1460,70 @@
 	return nil
 }
 
+func (x DummyStruct) VDLIsZero() bool {
+	return x == DummyStruct{}
+}
+
+func (x DummyStruct) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*DummyStruct)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.FInt8 != 0 {
+		if err := enc.NextField("FInt8"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int8Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(int64(x.FInt8)); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *DummyStruct) VDLRead(dec vdl.Decoder) error {
+	*x = DummyStruct{}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "FInt8":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			tmp, err := dec.DecodeInt(8)
+			if err != nil {
+				return err
+			}
+			x.FInt8 = int8(tmp)
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 type (
 	// ObjectUnion represents any single field of the ObjectUnion union type.
 	ObjectUnion interface {
@@ -859,6 +1536,8 @@
 		// __VDLReflect describes the ObjectUnion union type.
 		__VDLReflect(__ObjectUnionReflect)
 		FillVDLTarget(vdl.Target, *vdl.Type) error
+		VDLIsZero() bool
+		VDLWrite(vdl.Encoder) error
 	}
 	// ObjectUnionFInt8 represents field FInt8 of the ObjectUnion union type.
 	ObjectUnionFInt8 struct{ Value int8 }
@@ -1337,6 +2016,432 @@
 	return nil
 }
 
+func (x ObjectUnionFInt8) VDLIsZero() bool {
+	return x.Value == 0
+}
+
+func (x ObjectUnionFString) VDLIsZero() bool {
+	return false
+}
+
+func (x ObjectUnionFDummy) VDLIsZero() bool {
+	return false
+}
+
+func (x ObjectUnionFNullable) VDLIsZero() bool {
+	return false
+}
+
+func (x ObjectUnionFArrayInt8) VDLIsZero() bool {
+	return false
+}
+
+func (x ObjectUnionFMapInt8) VDLIsZero() bool {
+	return false
+}
+
+func (x ObjectUnionFPodUnion) VDLIsZero() bool {
+	return false
+}
+
+func (x ObjectUnionFInt8) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FInt8"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.Int8Type); err != nil {
+		return err
+	}
+	if err := enc.EncodeInt(int64(x.Value)); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x ObjectUnionFString) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FString"); err != nil {
+		return err
+	}
+	if err := enc.StartValue(vdl.StringType); err != nil {
+		return err
+	}
+	if err := enc.EncodeString(x.Value); err != nil {
+		return err
+	}
+	if err := enc.FinishValue(); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x ObjectUnionFDummy) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FDummy"); err != nil {
+		return err
+	}
+	if err := x.Value.VDLWrite(enc); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x ObjectUnionFNullable) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FNullable"); err != nil {
+		return err
+	}
+	if x.Value == nil {
+		if err := enc.NilValue(vdl.TypeOf((**DummyStruct)(nil))); err != nil {
+			return err
+		}
+	} else {
+		enc.SetNextStartValueIsOptional()
+		if err := enc.StartValue(vdl.TypeOf((*DummyStruct)(nil)).Elem()); err != nil {
+			return err
+		}
+		if err := x.Value.VDLWrite(enc); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x ObjectUnionFArrayInt8) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FArrayInt8"); err != nil {
+		return err
+	}
+	if err := __VDLWriteAnon_list_1(enc, x.Value); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x ObjectUnionFMapInt8) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FMapInt8"); err != nil {
+		return err
+	}
+	if err := __VDLWriteAnon_map_2(enc, x.Value); err != nil {
+		return err
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x ObjectUnionFPodUnion) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*ObjectUnion)(nil))); err != nil {
+		return err
+	}
+	if err := enc.NextField("FPodUnion"); err != nil {
+		return err
+	}
+	if err := x.Value.VDLWrite(enc); err != nil {
+		return err
+	}
+	switch {
+	case x.Value == nil:
+		// Write the zero value of the union type.
+		if err := vdl.ZeroValue(vdl.TypeOf((*PodUnion)(nil))).VDLWrite(enc); err != nil {
+			return err
+		}
+	default:
+		if err := x.Value.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func __VDLWriteAnon_list_1(enc vdl.Encoder, x []int8) error {
+	if err := enc.StartValue(vdl.TypeOf((*[]int8)(nil))); err != nil {
+		return err
+	}
+	if err := enc.SetLenHint(len(x)); err != nil {
+		return err
+	}
+	for i := 0; i < len(x); i++ {
+		if err := enc.NextEntry(false); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int8Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(int64(x[i])); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextEntry(true); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func __VDLWriteAnon_map_2(enc vdl.Encoder, x map[string]int8) error {
+	if err := enc.StartValue(vdl.TypeOf((*map[string]int8)(nil))); 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 := enc.StartValue(vdl.StringType); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(key); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int8Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(int64(elem)); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextEntry(true); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func VDLReadObjectUnion(dec vdl.Decoder, x *ObjectUnion) error {
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(x), dec.Type()) {
+		return fmt.Errorf("incompatible union %T, from %v", x, dec.Type())
+	}
+	f, err := dec.NextField()
+	if err != nil {
+		return err
+	}
+	switch f {
+	case "FInt8":
+		var field ObjectUnionFInt8
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		tmp, err := dec.DecodeInt(8)
+		if err != nil {
+			return err
+		}
+		field.Value = int8(tmp)
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FString":
+		var field ObjectUnionFString
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		var err error
+		if field.Value, err = dec.DecodeString(); err != nil {
+			return err
+		}
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = field
+	case "FDummy":
+		var field ObjectUnionFDummy
+		if err := field.Value.VDLRead(dec); err != nil {
+			return err
+		}
+		*x = field
+	case "FNullable":
+		var field ObjectUnionFNullable
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		if dec.IsNil() {
+			if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(field.Value), dec.Type()) {
+				return fmt.Errorf("incompatible optional %T, from %v", field.Value, dec.Type())
+			}
+			field.Value = nil
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		} else {
+			field.Value = new(DummyStruct)
+			dec.IgnoreNextStartValue()
+			if err := field.Value.VDLRead(dec); err != nil {
+				return err
+			}
+		}
+		*x = field
+	case "FArrayInt8":
+		var field ObjectUnionFArrayInt8
+		if err := __VDLReadAnon_list_1(dec, &field.Value); err != nil {
+			return err
+		}
+		*x = field
+	case "FMapInt8":
+		var field ObjectUnionFMapInt8
+		if err := __VDLReadAnon_map_2(dec, &field.Value); err != nil {
+			return err
+		}
+		*x = field
+	case "FPodUnion":
+		var field ObjectUnionFPodUnion
+		if err := VDLReadPodUnion(dec, &field.Value); err != nil {
+			return err
+		}
+		*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()
+}
+
+func __VDLReadAnon_list_1(dec vdl.Decoder, x *[]int8) error {
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type())
+	}
+	switch len := dec.LenHint(); {
+	case len > 0:
+		*x = make([]int8, 0, len)
+	default:
+		*x = nil
+	}
+	for {
+		switch done, err := dec.NextEntry(); {
+		case err != nil:
+			return err
+		case done:
+			return dec.FinishValue()
+		}
+		var elem int8
+		if err := dec.StartValue(); err != nil {
+			return err
+		}
+		tmp, err := dec.DecodeInt(8)
+		if err != nil {
+			return err
+		}
+		elem = int8(tmp)
+		if err := dec.FinishValue(); err != nil {
+			return err
+		}
+		*x = append(*x, elem)
+	}
+}
+
+func __VDLReadAnon_map_2(dec vdl.Decoder, x *map[string]int8) error {
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible map %T, from %v", *x, dec.Type())
+	}
+	var tmpMap map[string]int8
+	if len := dec.LenHint(); len > 0 {
+		tmpMap = make(map[string]int8, len)
+	}
+	for {
+		switch done, err := dec.NextEntry(); {
+		case err != nil:
+			return err
+		case done:
+			*x = tmpMap
+			return dec.FinishValue()
+		}
+		var key string
+		{
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if key, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		}
+		var elem int8
+		{
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			tmp, err := dec.DecodeInt(8)
+			if err != nil {
+				return err
+			}
+			elem = int8(tmp)
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		}
+		if tmpMap == nil {
+			tmpMap = make(map[string]int8)
+		}
+		tmpMap[key] = elem
+	}
+}
+
 type ObjectUnionWrapper struct {
 	ObjectUnion ObjectUnion
 }
@@ -1431,6 +2536,61 @@
 	return nil
 }
 
+func (x ObjectUnionWrapper) VDLIsZero() bool {
+	if x.ObjectUnion != nil && !x.ObjectUnion.VDLIsZero() {
+		return false
+	}
+	return true
+}
+
+func (x ObjectUnionWrapper) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*ObjectUnionWrapper)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.ObjectUnion != nil && !x.ObjectUnion.VDLIsZero() {
+		if err := enc.NextField("ObjectUnion"); err != nil {
+			return err
+		}
+		if err := x.ObjectUnion.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *ObjectUnionWrapper) VDLRead(dec vdl.Decoder) error {
+	*x = ObjectUnionWrapper{
+		ObjectUnion: ObjectUnionFInt8{},
+	}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "ObjectUnion":
+			if err := VDLReadObjectUnion(dec, &x.ObjectUnion); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 type Rect struct {
 	X      int32
 	Y      int32
@@ -1599,6 +2759,148 @@
 	return nil
 }
 
+func (x Rect) VDLIsZero() bool {
+	return x == Rect{}
+}
+
+func (x Rect) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*Rect)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.X != 0 {
+		if err := enc.NextField("X"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int32Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(int64(x.X)); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.Y != 0 {
+		if err := enc.NextField("Y"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int32Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(int64(x.Y)); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.Width != 0 {
+		if err := enc.NextField("Width"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int32Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(int64(x.Width)); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.Height != 0 {
+		if err := enc.NextField("Height"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int32Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(int64(x.Height)); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *Rect) VDLRead(dec vdl.Decoder) error {
+	*x = Rect{}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "X":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			tmp, err := dec.DecodeInt(32)
+			if err != nil {
+				return err
+			}
+			x.X = int32(tmp)
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "Y":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			tmp, err := dec.DecodeInt(32)
+			if err != nil {
+				return err
+			}
+			x.Y = int32(tmp)
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "Width":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			tmp, err := dec.DecodeInt(32)
+			if err != nil {
+				return err
+			}
+			x.Width = int32(tmp)
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "Height":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			tmp, err := dec.DecodeInt(32)
+			if err != nil {
+				return err
+			}
+			x.Height = int32(tmp)
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 type MultiVersionStruct struct {
 	FInt32  int32
 	FRect   Rect
@@ -1844,6 +3146,188 @@
 	return nil
 }
 
+func (x MultiVersionStruct) VDLIsZero() bool {
+	if x.FInt32 != 0 {
+		return false
+	}
+	if x.FRect != (Rect{}) {
+		return false
+	}
+	if x.FString != "" {
+		return false
+	}
+	if len(x.FArray) != 0 {
+		return false
+	}
+	if x.FBool {
+		return false
+	}
+	if x.FInt16 != 0 {
+		return false
+	}
+	return true
+}
+
+func (x MultiVersionStruct) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*MultiVersionStruct)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.FInt32 != 0 {
+		if err := enc.NextField("FInt32"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int32Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(int64(x.FInt32)); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.FRect != (Rect{}) {
+		if err := enc.NextField("FRect"); err != nil {
+			return err
+		}
+		if err := x.FRect.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if x.FString != "" {
+		if err := enc.NextField("FString"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.StringType); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(x.FString); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if len(x.FArray) != 0 {
+		if err := enc.NextField("FArray"); err != nil {
+			return err
+		}
+		if err := __VDLWriteAnon_list_1(enc, x.FArray); err != nil {
+			return err
+		}
+	}
+	if x.FBool {
+		if err := enc.NextField("FBool"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.BoolType); err != nil {
+			return err
+		}
+		if err := enc.EncodeBool(x.FBool); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.FInt16 != 0 {
+		if err := enc.NextField("FInt16"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int16Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(int64(x.FInt16)); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *MultiVersionStruct) VDLRead(dec vdl.Decoder) error {
+	*x = MultiVersionStruct{}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "FInt32":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			tmp, err := dec.DecodeInt(32)
+			if err != nil {
+				return err
+			}
+			x.FInt32 = int32(tmp)
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "FRect":
+			if err := x.FRect.VDLRead(dec); err != nil {
+				return err
+			}
+		case "FString":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.FString, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "FArray":
+			if err := __VDLReadAnon_list_1(dec, &x.FArray); err != nil {
+				return err
+			}
+		case "FBool":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.FBool, err = dec.DecodeBool(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "FInt16":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			tmp, err := dec.DecodeInt(16)
+			if err != nil {
+				return err
+			}
+			x.FInt16 = int16(tmp)
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 type MultiVersionStructV3 struct {
 	FInt32  int32
 	FRect   Rect
@@ -1985,6 +3469,107 @@
 	return nil
 }
 
+func (x MultiVersionStructV3) VDLIsZero() bool {
+	return x == MultiVersionStructV3{}
+}
+
+func (x MultiVersionStructV3) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*MultiVersionStructV3)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.FInt32 != 0 {
+		if err := enc.NextField("FInt32"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.Int32Type); err != nil {
+			return err
+		}
+		if err := enc.EncodeInt(int64(x.FInt32)); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.FRect != (Rect{}) {
+		if err := enc.NextField("FRect"); err != nil {
+			return err
+		}
+		if err := x.FRect.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if x.FString != "" {
+		if err := enc.NextField("FString"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.StringType); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(x.FString); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
+func (x *MultiVersionStructV3) VDLRead(dec vdl.Decoder) error {
+	*x = MultiVersionStructV3{}
+	if err := dec.StartValue(); err != nil {
+		return err
+	}
+	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
+		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	}
+	for {
+		f, err := dec.NextField()
+		if err != nil {
+			return err
+		}
+		switch f {
+		case "":
+			return dec.FinishValue()
+		case "FInt32":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			tmp, err := dec.DecodeInt(32)
+			if err != nil {
+				return err
+			}
+			x.FInt32 = int32(tmp)
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "FRect":
+			if err := x.FRect.VDLRead(dec); err != nil {
+				return err
+			}
+		case "FString":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.FString, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 var __VDLInitCalled bool
 
 // __VDLInit performs vdl initialization.  It is safe to call multiple times.