diff --git a/go/src/v.io/x/sensorlog/internal/sbmodel/sbmodel.vdl.go b/go/src/v.io/x/sensorlog/internal/sbmodel/sbmodel.vdl.go
index fd37d0b..4aad326 100644
--- a/go/src/v.io/x/sensorlog/internal/sbmodel/sbmodel.vdl.go
+++ b/go/src/v.io/x/sensorlog/internal/sbmodel/sbmodel.vdl.go
@@ -141,57 +141,15 @@
 	return nil
 }
 
-func (x *VDeviceCfg) VDLRead(dec vdl.Decoder) error {
-	*x = VDeviceCfg{}
-	var err 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 struct %T, from %v", *x, dec.Type())
-	}
-	for {
-		f, err := dec.NextField()
-		if err != nil {
-			return err
-		}
-		switch f {
-		case "":
-			return dec.FinishValue()
-		case "Desc":
-			if err = dec.StartValue(); err != nil {
-				return err
-			}
-			if x.Desc, err = dec.DecodeString(); err != nil {
-				return err
-			}
-			if err = dec.FinishValue(); err != nil {
-				return err
-			}
-		case "SgPublishSb":
-			if err = dec.StartValue(); err != nil {
-				return err
-			}
-			if x.SgPublishSb, err = dec.DecodeString(); err != nil {
-				return err
-			}
-			if err = dec.FinishValue(); err != nil {
-				return err
-			}
-		default:
-			if err = dec.SkipValue(); err != nil {
-				return err
-			}
-		}
-	}
+func (x VDeviceCfg) VDLIsZero() (bool, error) {
+	return x == VDeviceCfg{}, nil
 }
 
 func (x VDeviceCfg) VDLWrite(enc vdl.Encoder) error {
 	if err := enc.StartValue(vdl.TypeOf((*VDeviceCfg)(nil)).Elem()); err != nil {
 		return err
 	}
-	var1 := (x.Desc == "")
-	if !(var1) {
+	if x.Desc != "" {
 		if err := enc.NextField("Desc"); err != nil {
 			return err
 		}
@@ -205,8 +163,7 @@
 			return err
 		}
 	}
-	var2 := (x.SgPublishSb == "")
-	if !(var2) {
+	if x.SgPublishSb != "" {
 		if err := enc.NextField("SgPublishSb"); err != nil {
 			return err
 		}
@@ -226,6 +183,52 @@
 	return enc.FinishValue()
 }
 
+func (x *VDeviceCfg) VDLRead(dec vdl.Decoder) error {
+	*x = VDeviceCfg{}
+	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 "Desc":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.Desc, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "SgPublishSb":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.SgPublishSb, 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 KDeviceCfg struct {
 	DevId string
 }
@@ -310,47 +313,15 @@
 	return nil
 }
 
-func (x *KDeviceCfg) VDLRead(dec vdl.Decoder) error {
-	*x = KDeviceCfg{}
-	var err 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 struct %T, from %v", *x, dec.Type())
-	}
-	for {
-		f, err := dec.NextField()
-		if err != nil {
-			return err
-		}
-		switch f {
-		case "":
-			return dec.FinishValue()
-		case "DevId":
-			if err = dec.StartValue(); err != nil {
-				return err
-			}
-			if x.DevId, err = dec.DecodeString(); err != nil {
-				return err
-			}
-			if err = dec.FinishValue(); err != nil {
-				return err
-			}
-		default:
-			if err = dec.SkipValue(); err != nil {
-				return err
-			}
-		}
-	}
+func (x KDeviceCfg) VDLIsZero() (bool, error) {
+	return x == KDeviceCfg{}, nil
 }
 
 func (x KDeviceCfg) VDLWrite(enc vdl.Encoder) error {
 	if err := enc.StartValue(vdl.TypeOf((*KDeviceCfg)(nil)).Elem()); err != nil {
 		return err
 	}
-	var1 := (x.DevId == "")
-	if !(var1) {
+	if x.DevId != "" {
 		if err := enc.NextField("DevId"); err != nil {
 			return err
 		}
@@ -370,6 +341,41 @@
 	return enc.FinishValue()
 }
 
+func (x *KDeviceCfg) VDLRead(dec vdl.Decoder) error {
+	*x = KDeviceCfg{}
+	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 "DevId":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.DevId, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 // Sampling script and polling frequency.
 type SamplerDef struct {
 	// Shell script executed after every Interval, starting from Start.
@@ -538,10 +544,78 @@
 	return nil
 }
 
+func (x SamplerDef) VDLIsZero() (bool, error) {
+	if x.Script != "" {
+		return false, nil
+	}
+	var wireStart time_2.Time
+	if err := time_2.TimeFromNative(&wireStart, x.Start); err != nil {
+		return false, err
+	}
+	if wireStart != (time_2.Time{}) {
+		return false, nil
+	}
+	var wireInterval time_2.Duration
+	if err := time_2.DurationFromNative(&wireInterval, x.Interval); err != nil {
+		return false, err
+	}
+	if wireInterval != (time_2.Duration{}) {
+		return false, nil
+	}
+	return true, nil
+}
+
+func (x SamplerDef) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*SamplerDef)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.Script != "" {
+		if err := enc.NextField("Script"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(x.Script); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	var wireStart time_2.Time
+	if err := time_2.TimeFromNative(&wireStart, x.Start); err != nil {
+		return err
+	}
+	if wireStart != (time_2.Time{}) {
+		if err := enc.NextField("Start"); err != nil {
+			return err
+		}
+		if err := wireStart.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	var wireInterval time_2.Duration
+	if err := time_2.DurationFromNative(&wireInterval, x.Interval); err != nil {
+		return err
+	}
+	if wireInterval != (time_2.Duration{}) {
+		if err := enc.NextField("Interval"); err != nil {
+			return err
+		}
+		if err := wireInterval.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
 func (x *SamplerDef) VDLRead(dec vdl.Decoder) error {
 	*x = SamplerDef{}
-	var err error
-	if err = dec.StartValue(); err != nil {
+	if err := dec.StartValue(); err != nil {
 		return err
 	}
 	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
@@ -556,100 +630,40 @@
 		case "":
 			return dec.FinishValue()
 		case "Script":
-			if err = dec.StartValue(); err != nil {
+			if err := dec.StartValue(); err != nil {
 				return err
 			}
+			var err error
 			if x.Script, err = dec.DecodeString(); err != nil {
 				return err
 			}
-			if err = dec.FinishValue(); err != nil {
+			if err := dec.FinishValue(); err != nil {
 				return err
 			}
 		case "Start":
 			var wire time_2.Time
-			if err = wire.VDLRead(dec); err != nil {
+			if err := wire.VDLRead(dec); err != nil {
 				return err
 			}
-			if err = time_2.TimeToNative(wire, &x.Start); err != nil {
+			if err := time_2.TimeToNative(wire, &x.Start); err != nil {
 				return err
 			}
 		case "Interval":
 			var wire time_2.Duration
-			if err = wire.VDLRead(dec); err != nil {
+			if err := wire.VDLRead(dec); err != nil {
 				return err
 			}
-			if err = time_2.DurationToNative(wire, &x.Interval); err != nil {
+			if err := time_2.DurationToNative(wire, &x.Interval); err != nil {
 				return err
 			}
 		default:
-			if err = dec.SkipValue(); err != nil {
+			if err := dec.SkipValue(); err != nil {
 				return err
 			}
 		}
 	}
 }
 
-func (x SamplerDef) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(vdl.TypeOf((*SamplerDef)(nil)).Elem()); err != nil {
-		return err
-	}
-	var1 := (x.Script == "")
-	if !(var1) {
-		if err := enc.NextField("Script"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Script); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
-			return err
-		}
-	}
-	var wireValue2 time_2.Time
-	if err := time_2.TimeFromNative(&wireValue2, x.Start); err != nil {
-		return fmt.Errorf("error converting x.Start to wiretype")
-	}
-
-	var3 := (wireValue2 == time_2.Time{})
-	if !(var3) {
-		if err := enc.NextField("Start"); err != nil {
-			return err
-		}
-		var wire time_2.Time
-		if err := time_2.TimeFromNative(&wire, x.Start); err != nil {
-			return err
-		}
-		if err := wire.VDLWrite(enc); err != nil {
-			return err
-		}
-	}
-	var wireValue4 time_2.Duration
-	if err := time_2.DurationFromNative(&wireValue4, x.Interval); err != nil {
-		return fmt.Errorf("error converting x.Interval to wiretype")
-	}
-
-	var5 := (wireValue4 == time_2.Duration{})
-	if !(var5) {
-		if err := enc.NextField("Interval"); err != nil {
-			return err
-		}
-		var wire time_2.Duration
-		if err := time_2.DurationFromNative(&wire, x.Interval); err != nil {
-			return err
-		}
-		if err := wire.VDLWrite(enc); err != nil {
-			return err
-		}
-	}
-	if err := enc.NextField(""); err != nil {
-		return err
-	}
-	return enc.FinishValue()
-}
-
 // streamdef : <DevId>/<StreamId>
 // Configures a stream of data to be measured.
 type VStreamDef struct {
@@ -796,61 +810,28 @@
 	return nil
 }
 
-func (x *VStreamDef) VDLRead(dec vdl.Decoder) error {
-	*x = VStreamDef{}
-	var err error
-	if err = dec.StartValue(); err != nil {
-		return err
+func (x VStreamDef) VDLIsZero() (bool, error) {
+	if x.Desc != "" {
+		return false, nil
 	}
-	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
-		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
+	isZeroSampler, err := x.Sampler.VDLIsZero()
+	if err != nil {
+		return false, err
 	}
-	for {
-		f, err := dec.NextField()
-		if err != nil {
-			return err
-		}
-		switch f {
-		case "":
-			return dec.FinishValue()
-		case "Desc":
-			if err = dec.StartValue(); err != nil {
-				return err
-			}
-			if x.Desc, err = dec.DecodeString(); err != nil {
-				return err
-			}
-			if err = dec.FinishValue(); err != nil {
-				return err
-			}
-		case "Sampler":
-			if err = x.Sampler.VDLRead(dec); err != nil {
-				return err
-			}
-		case "Enabled":
-			if err = dec.StartValue(); err != nil {
-				return err
-			}
-			if x.Enabled, err = dec.DecodeBool(); err != nil {
-				return err
-			}
-			if err = dec.FinishValue(); err != nil {
-				return err
-			}
-		default:
-			if err = dec.SkipValue(); err != nil {
-				return err
-			}
-		}
+	if !isZeroSampler {
+		return false, nil
 	}
+	if x.Enabled {
+		return false, nil
+	}
+	return true, nil
 }
 
 func (x VStreamDef) VDLWrite(enc vdl.Encoder) error {
 	if err := enc.StartValue(vdl.TypeOf((*VStreamDef)(nil)).Elem()); err != nil {
 		return err
 	}
-	var1 := (x.Desc == "")
-	if !(var1) {
+	if x.Desc != "" {
 		if err := enc.NextField("Desc"); err != nil {
 			return err
 		}
@@ -864,8 +845,11 @@
 			return err
 		}
 	}
-	var2 := (x.Sampler == SamplerDef{})
-	if !(var2) {
+	isZeroSampler, err := x.Sampler.VDLIsZero()
+	if err != nil {
+		return err
+	}
+	if !isZeroSampler {
 		if err := enc.NextField("Sampler"); err != nil {
 			return err
 		}
@@ -873,8 +857,7 @@
 			return err
 		}
 	}
-	var3 := (x.Enabled == false)
-	if !(var3) {
+	if x.Enabled {
 		if err := enc.NextField("Enabled"); err != nil {
 			return err
 		}
@@ -894,6 +877,56 @@
 	return enc.FinishValue()
 }
 
+func (x *VStreamDef) VDLRead(dec vdl.Decoder) error {
+	*x = VStreamDef{}
+	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 "Desc":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.Desc, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "Sampler":
+			if err := x.Sampler.VDLRead(dec); err != nil {
+				return err
+			}
+		case "Enabled":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.Enabled, err = dec.DecodeBool(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 type KStreamDef struct {
 	DevId    string
 	StreamId string
@@ -1006,57 +1039,15 @@
 	return nil
 }
 
-func (x *KStreamDef) VDLRead(dec vdl.Decoder) error {
-	*x = KStreamDef{}
-	var err 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 struct %T, from %v", *x, dec.Type())
-	}
-	for {
-		f, err := dec.NextField()
-		if err != nil {
-			return err
-		}
-		switch f {
-		case "":
-			return dec.FinishValue()
-		case "DevId":
-			if err = dec.StartValue(); err != nil {
-				return err
-			}
-			if x.DevId, err = dec.DecodeString(); err != nil {
-				return err
-			}
-			if err = dec.FinishValue(); err != nil {
-				return err
-			}
-		case "StreamId":
-			if err = dec.StartValue(); err != nil {
-				return err
-			}
-			if x.StreamId, err = dec.DecodeString(); err != nil {
-				return err
-			}
-			if err = dec.FinishValue(); err != nil {
-				return err
-			}
-		default:
-			if err = dec.SkipValue(); err != nil {
-				return err
-			}
-		}
-	}
+func (x KStreamDef) VDLIsZero() (bool, error) {
+	return x == KStreamDef{}, nil
 }
 
 func (x KStreamDef) VDLWrite(enc vdl.Encoder) error {
 	if err := enc.StartValue(vdl.TypeOf((*KStreamDef)(nil)).Elem()); err != nil {
 		return err
 	}
-	var1 := (x.DevId == "")
-	if !(var1) {
+	if x.DevId != "" {
 		if err := enc.NextField("DevId"); err != nil {
 			return err
 		}
@@ -1070,8 +1061,7 @@
 			return err
 		}
 	}
-	var2 := (x.StreamId == "")
-	if !(var2) {
+	if x.StreamId != "" {
 		if err := enc.NextField("StreamId"); err != nil {
 			return err
 		}
@@ -1091,6 +1081,52 @@
 	return enc.FinishValue()
 }
 
+func (x *KStreamDef) VDLRead(dec vdl.Decoder) error {
+	*x = KStreamDef{}
+	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 "DevId":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.DevId, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		case "StreamId":
+			if err := dec.StartValue(); err != nil {
+				return err
+			}
+			var err error
+			if x.StreamId, err = dec.DecodeString(); err != nil {
+				return err
+			}
+			if err := dec.FinishValue(); err != nil {
+				return err
+			}
+		default:
+			if err := dec.SkipValue(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
 // sdata : <DevId>/<StreamId>/<Timestamp>
 // Measured data value or error.
 type KDataPoint struct {
@@ -1245,10 +1281,76 @@
 	return nil
 }
 
+func (x KDataPoint) VDLIsZero() (bool, error) {
+	if x.DevId != "" {
+		return false, nil
+	}
+	if x.StreamId != "" {
+		return false, nil
+	}
+	var wireTimestamp time_2.Time
+	if err := time_2.TimeFromNative(&wireTimestamp, x.Timestamp); err != nil {
+		return false, err
+	}
+	if wireTimestamp != (time_2.Time{}) {
+		return false, nil
+	}
+	return true, nil
+}
+
+func (x KDataPoint) VDLWrite(enc vdl.Encoder) error {
+	if err := enc.StartValue(vdl.TypeOf((*KDataPoint)(nil)).Elem()); err != nil {
+		return err
+	}
+	if x.DevId != "" {
+		if err := enc.NextField("DevId"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(x.DevId); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	if x.StreamId != "" {
+		if err := enc.NextField("StreamId"); err != nil {
+			return err
+		}
+		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
+			return err
+		}
+		if err := enc.EncodeString(x.StreamId); err != nil {
+			return err
+		}
+		if err := enc.FinishValue(); err != nil {
+			return err
+		}
+	}
+	var wireTimestamp time_2.Time
+	if err := time_2.TimeFromNative(&wireTimestamp, x.Timestamp); err != nil {
+		return err
+	}
+	if wireTimestamp != (time_2.Time{}) {
+		if err := enc.NextField("Timestamp"); err != nil {
+			return err
+		}
+		if err := wireTimestamp.VDLWrite(enc); err != nil {
+			return err
+		}
+	}
+	if err := enc.NextField(""); err != nil {
+		return err
+	}
+	return enc.FinishValue()
+}
+
 func (x *KDataPoint) VDLRead(dec vdl.Decoder) error {
 	*x = KDataPoint{}
-	var err error
-	if err = dec.StartValue(); err != nil {
+	if err := dec.StartValue(); err != nil {
 		return err
 	}
 	if (dec.StackDepth() == 1 || dec.IsAny()) && !vdl.Compatible(vdl.TypeOf(*x), dec.Type()) {
@@ -1263,99 +1365,43 @@
 		case "":
 			return dec.FinishValue()
 		case "DevId":
-			if err = dec.StartValue(); err != nil {
+			if err := dec.StartValue(); err != nil {
 				return err
 			}
+			var err error
 			if x.DevId, err = dec.DecodeString(); err != nil {
 				return err
 			}
-			if err = dec.FinishValue(); err != nil {
+			if err := dec.FinishValue(); err != nil {
 				return err
 			}
 		case "StreamId":
-			if err = dec.StartValue(); err != nil {
+			if err := dec.StartValue(); err != nil {
 				return err
 			}
+			var err error
 			if x.StreamId, err = dec.DecodeString(); err != nil {
 				return err
 			}
-			if err = dec.FinishValue(); err != nil {
+			if err := dec.FinishValue(); err != nil {
 				return err
 			}
 		case "Timestamp":
 			var wire time_2.Time
-			if err = wire.VDLRead(dec); err != nil {
+			if err := wire.VDLRead(dec); err != nil {
 				return err
 			}
-			if err = time_2.TimeToNative(wire, &x.Timestamp); err != nil {
+			if err := time_2.TimeToNative(wire, &x.Timestamp); err != nil {
 				return err
 			}
 		default:
-			if err = dec.SkipValue(); err != nil {
+			if err := dec.SkipValue(); err != nil {
 				return err
 			}
 		}
 	}
 }
 
-func (x KDataPoint) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(vdl.TypeOf((*KDataPoint)(nil)).Elem()); err != nil {
-		return err
-	}
-	var1 := (x.DevId == "")
-	if !(var1) {
-		if err := enc.NextField("DevId"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.DevId); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
-			return err
-		}
-	}
-	var2 := (x.StreamId == "")
-	if !(var2) {
-		if err := enc.NextField("StreamId"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.TypeOf((*string)(nil))); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.StreamId); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
-			return err
-		}
-	}
-	var wireValue3 time_2.Time
-	if err := time_2.TimeFromNative(&wireValue3, x.Timestamp); err != nil {
-		return fmt.Errorf("error converting x.Timestamp to wiretype")
-	}
-
-	var4 := (wireValue3 == time_2.Time{})
-	if !(var4) {
-		if err := enc.NextField("Timestamp"); err != nil {
-			return err
-		}
-		var wire time_2.Time
-		if err := time_2.TimeFromNative(&wire, x.Timestamp); err != nil {
-			return err
-		}
-		if err := wire.VDLWrite(enc); err != nil {
-			return err
-		}
-	}
-	if err := enc.NextField(""); err != nil {
-		return err
-	}
-	return enc.FinishValue()
-}
-
 type (
 	// VDataPoint represents any single field of the VDataPoint union type.
 	VDataPoint interface {
@@ -1368,6 +1414,7 @@
 		// __VDLReflect describes the VDataPoint union type.
 		__VDLReflect(__VDataPointReflect)
 		FillVDLTarget(vdl.Target, *vdl.Type) error
+		VDLIsZero() (bool, error)
 		VDLWrite(vdl.Encoder) error
 	}
 	// VDataPointValue represents field Value of the VDataPoint union type.
@@ -1499,55 +1546,12 @@
 	return nil, fmt.Errorf("got %T, want *VDataPoint", union)
 }
 
-func VDLReadVDataPoint(dec vdl.Decoder, x *VDataPoint) error {
-	var err 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 "Value":
-		var field VDataPointValue
-		if err = dec.StartValue(); err != nil {
-			return err
-		}
-		if field.Value, err = dec.DecodeFloat(64); err != nil {
-			return err
-		}
-		if err = dec.FinishValue(); err != nil {
-			return err
-		}
-		*x = field
-	case "Error":
-		var field VDataPointError
-		if err = dec.StartValue(); err != nil {
-			return err
-		}
-		if field.Value, err = dec.DecodeString(); err != nil {
-			return err
-		}
-		if err = dec.FinishValue(); 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 (x VDataPointValue) VDLIsZero() (bool, error) {
+	return x.Value == 0, nil
+}
+
+func (x VDataPointError) VDLIsZero() (bool, error) {
+	return false, nil
 }
 
 func (x VDataPointValue) VDLWrite(enc vdl.Encoder) error {
@@ -1571,6 +1575,7 @@
 	}
 	return enc.FinishValue()
 }
+
 func (x VDataPointError) VDLWrite(enc vdl.Encoder) error {
 	if err := enc.StartValue(vdl.TypeOf((*VDataPoint)(nil))); err != nil {
 		return err
@@ -1593,6 +1598,58 @@
 	return enc.FinishValue()
 }
 
+func VDLReadVDataPoint(dec vdl.Decoder, x *VDataPoint) 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 "Value":
+		var field VDataPointValue
+		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 "Error":
+		var field VDataPointError
+		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 "":
+		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()
+}
+
 var __VDLInitCalled bool
 
 // __VDLInit performs vdl initialization.  It is safe to call multiple times.