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

// Syncbase data model for Sensor Log.
//
// Every type <T> stored in Syncbase is defined as a pair of types, K<T> and
// V<T>, representing data stored in the key and value, respectively, in a
// single table. K<T> types satisfy the PersistentDataKey interface, supporting
// conversion to and from the row key.
package sbmodel

import (
	"fmt"
	"time"
	"v.io/v23/vdl"
	time_2 "v.io/v23/vdlroot/time"
)

// devicecfg : <DevId>
// Measuring device handle. Master only.
type VDeviceCfg struct {
	// Human-readable, not necessarily unique description of the device.
	Desc string
	// Syncbase instance publishing the syncgroup created by the device.
	SgPublishSb string
}

func (VDeviceCfg) __VDLReflect(struct {
	Name string `vdl:"v.io/x/sensorlog/internal/sbmodel.VDeviceCfg"`
}) {
}

func (m *VDeviceCfg) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_v_io_x_sensorlog_internal_sbmodel_VDeviceCfg == nil || __VDLType0 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Desc")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Desc), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("SgPublishSb")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromString(string(m.SgPublishSb), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *VDeviceCfg) MakeVDLTarget() vdl.Target {
	return &VDeviceCfgTarget{Value: m}
}

type VDeviceCfgTarget struct {
	Value             *VDeviceCfg
	descTarget        vdl.StringTarget
	sgPublishSbTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *VDeviceCfgTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_v_io_x_sensorlog_internal_sbmodel_VDeviceCfg) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_v_io_x_sensorlog_internal_sbmodel_VDeviceCfg)
	}
	return t, nil
}
func (t *VDeviceCfgTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Desc":
		t.descTarget.Value = &t.Value.Desc
		target, err := &t.descTarget, error(nil)
		return nil, target, err
	case "SgPublishSb":
		t.sgPublishSbTarget.Value = &t.Value.SgPublishSb
		target, err := &t.sgPublishSbTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_v_io_x_sensorlog_internal_sbmodel_VDeviceCfg)
	}
}
func (t *VDeviceCfgTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *VDeviceCfgTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type KDeviceCfg struct {
	DevId string
}

func (KDeviceCfg) __VDLReflect(struct {
	Name string `vdl:"v.io/x/sensorlog/internal/sbmodel.KDeviceCfg"`
}) {
}

func (m *KDeviceCfg) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_v_io_x_sensorlog_internal_sbmodel_KDeviceCfg == nil || __VDLType1 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("DevId")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.DevId), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *KDeviceCfg) MakeVDLTarget() vdl.Target {
	return &KDeviceCfgTarget{Value: m}
}

type KDeviceCfgTarget struct {
	Value       *KDeviceCfg
	devIdTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

// streamdef : <DevId>/<StreamId>
// Configures a stream of data to be measured.
type VStreamDef struct {
	// Human-readable, not necessarily unique description of the stream.
	Desc string
	// Sampling configuration.
	Sampler SamplerDef
	// Flag to start and stop sampling.
	Enabled bool
}

func (VStreamDef) __VDLReflect(struct {
	Name string `vdl:"v.io/x/sensorlog/internal/sbmodel.VStreamDef"`
}) {
}

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

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Desc")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Desc), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Sampler")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Sampler.FillVDLTarget(fieldTarget5, __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Enabled")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget7.FromBool(bool(m.Enabled), vdl.BoolType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *VStreamDef) MakeVDLTarget() vdl.Target {
	return &VStreamDefTarget{Value: m}
}

type VStreamDefTarget struct {
	Value         *VStreamDef
	descTarget    vdl.StringTarget
	samplerTarget SamplerDefTarget
	enabledTarget vdl.BoolTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *VStreamDefTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef)
	}
	return t, nil
}
func (t *VStreamDefTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Desc":
		t.descTarget.Value = &t.Value.Desc
		target, err := &t.descTarget, error(nil)
		return nil, target, err
	case "Sampler":
		t.samplerTarget.Value = &t.Value.Sampler
		target, err := &t.samplerTarget, error(nil)
		return nil, target, err
	case "Enabled":
		t.enabledTarget.Value = &t.Value.Enabled
		target, err := &t.enabledTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef)
	}
}
func (t *VStreamDefTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *VStreamDefTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type SamplerDefTarget struct {
	Value          *SamplerDef
	scriptTarget   vdl.StringTarget
	startTarget    time_2.TimeTarget
	intervalTarget time_2.DurationTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *SamplerDefTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef)
	}
	return t, nil
}
func (t *SamplerDefTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Script":
		t.scriptTarget.Value = &t.Value.Script
		target, err := &t.scriptTarget, error(nil)
		return nil, target, err
	case "Start":
		t.startTarget.Value = &t.Value.Start
		target, err := &t.startTarget, error(nil)
		return nil, target, err
	case "Interval":
		t.intervalTarget.Value = &t.Value.Interval
		target, err := &t.intervalTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef)
	}
}
func (t *SamplerDefTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *SamplerDefTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type KStreamDef struct {
	DevId    string
	StreamId string
}

func (KStreamDef) __VDLReflect(struct {
	Name string `vdl:"v.io/x/sensorlog/internal/sbmodel.KStreamDef"`
}) {
}

func (m *KStreamDef) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_v_io_x_sensorlog_internal_sbmodel_KStreamDef == nil || __VDLType3 == nil {
		panic("Initialization order error: types generated for FillVDLTarget not initialized. Consider moving caller to an init() block.")
	}
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("DevId")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.DevId), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("StreamId")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromString(string(m.StreamId), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *KStreamDef) MakeVDLTarget() vdl.Target {
	return &KStreamDefTarget{Value: m}
}

type KStreamDefTarget struct {
	Value          *KStreamDef
	devIdTarget    vdl.StringTarget
	streamIdTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *KStreamDefTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_v_io_x_sensorlog_internal_sbmodel_KStreamDef) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_v_io_x_sensorlog_internal_sbmodel_KStreamDef)
	}
	return t, nil
}
func (t *KStreamDefTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "DevId":
		t.devIdTarget.Value = &t.Value.DevId
		target, err := &t.devIdTarget, error(nil)
		return nil, target, err
	case "StreamId":
		t.streamIdTarget.Value = &t.Value.StreamId
		target, err := &t.streamIdTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_v_io_x_sensorlog_internal_sbmodel_KStreamDef)
	}
}
func (t *KStreamDefTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *KStreamDefTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// Sampling script and polling frequency.
type SamplerDef struct {
	// Shell script executed after every Interval, starting from Start.
	// It should output a single data point, if available. A non-zero exit
	// status or failure to parse the value will produce an error instead.
	Script   string
	Start    time.Time
	Interval time.Duration
}

func (SamplerDef) __VDLReflect(struct {
	Name string `vdl:"v.io/x/sensorlog/internal/sbmodel.SamplerDef"`
}) {
}

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

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Script")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Script), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	var wireValue4 time_2.Time
	if err := time_2.TimeFromNative(&wireValue4, m.Start); err != nil {
		return err
	}

	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Start")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := wireValue4.FillVDLTarget(fieldTarget6, __VDLType_time_Time); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
			return err
		}
	}
	var wireValue7 time_2.Duration
	if err := time_2.DurationFromNative(&wireValue7, m.Interval); err != nil {
		return err
	}

	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Interval")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := wireValue7.FillVDLTarget(fieldTarget9, __VDLType_time_Duration); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *SamplerDef) MakeVDLTarget() vdl.Target {
	return &SamplerDefTarget{Value: m}
}

// sdata : <DevId>/<StreamId>/<Timestamp>
// Measured data value or error.
type KDataPoint struct {
	DevId     string
	StreamId  string
	Timestamp time.Time
}

func (KDataPoint) __VDLReflect(struct {
	Name string `vdl:"v.io/x/sensorlog/internal/sbmodel.KDataPoint"`
}) {
}

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

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("DevId")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.DevId), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("StreamId")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromString(string(m.StreamId), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	var wireValue6 time_2.Time
	if err := time_2.TimeFromNative(&wireValue6, m.Timestamp); err != nil {
		return err
	}

	keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Timestamp")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := wireValue6.FillVDLTarget(fieldTarget8, __VDLType_time_Time); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *KDataPoint) MakeVDLTarget() vdl.Target {
	return &KDataPointTarget{Value: m}
}

type KDataPointTarget struct {
	Value           *KDataPoint
	devIdTarget     vdl.StringTarget
	streamIdTarget  vdl.StringTarget
	timestampTarget time_2.TimeTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *KDataPointTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint)
	}
	return t, nil
}
func (t *KDataPointTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "DevId":
		t.devIdTarget.Value = &t.Value.DevId
		target, err := &t.devIdTarget, error(nil)
		return nil, target, err
	case "StreamId":
		t.streamIdTarget.Value = &t.Value.StreamId
		target, err := &t.streamIdTarget, error(nil)
		return nil, target, err
	case "Timestamp":
		t.timestampTarget.Value = &t.Value.Timestamp
		target, err := &t.timestampTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint)
	}
}
func (t *KDataPointTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *KDataPointTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type (
	// VDataPoint represents any single field of the VDataPoint union type.
	VDataPoint 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 VDataPoint union type.
		__VDLReflect(__VDataPointReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
	}
	// VDataPointValue represents field Value of the VDataPoint union type.
	VDataPointValue struct{ Value float64 }
	// VDataPointError represents field Error of the VDataPoint union type.
	VDataPointError struct{ Value string }
	// __VDataPointReflect describes the VDataPoint union type.
	__VDataPointReflect struct {
		Name  string `vdl:"v.io/x/sensorlog/internal/sbmodel.VDataPoint"`
		Type  VDataPoint
		Union struct {
			Value VDataPointValue
			Error VDataPointError
		}
	}
)

func (x VDataPointValue) Index() int                       { return 0 }
func (x VDataPointValue) Interface() interface{}           { return x.Value }
func (x VDataPointValue) Name() string                     { return "Value" }
func (x VDataPointValue) __VDLReflect(__VDataPointReflect) {}

func (m VDataPointValue) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(__VDLType_v_io_x_sensorlog_internal_sbmodel_VDataPoint)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Value")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromFloat(float64(m.Value), vdl.Float64Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

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

func (x VDataPointError) Index() int                       { return 1 }
func (x VDataPointError) Interface() interface{}           { return x.Value }
func (x VDataPointError) Name() string                     { return "Error" }
func (x VDataPointError) __VDLReflect(__VDataPointReflect) {}

func (m VDataPointError) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(__VDLType_v_io_x_sensorlog_internal_sbmodel_VDataPoint)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Error")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromString(string(m.Value), vdl.StringType); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

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

func init() {
	vdl.Register((*VDeviceCfg)(nil))
	vdl.Register((*KDeviceCfg)(nil))
	vdl.Register((*VStreamDef)(nil))
	vdl.Register((*KStreamDef)(nil))
	vdl.Register((*SamplerDef)(nil))
	vdl.Register((*KDataPoint)(nil))
	vdl.Register((*VDataPoint)(nil))
}

var __VDLType5 *vdl.Type

func __VDLType5_gen() *vdl.Type {
	__VDLType5Builder := vdl.TypeBuilder{}

	__VDLType51 := __VDLType5Builder.Optional()
	__VDLType52 := __VDLType5Builder.Struct()
	__VDLType53 := __VDLType5Builder.Named("v.io/x/sensorlog/internal/sbmodel.KDataPoint").AssignBase(__VDLType52)
	__VDLType54 := vdl.StringType
	__VDLType52.AppendField("DevId", __VDLType54)
	__VDLType52.AppendField("StreamId", __VDLType54)
	__VDLType55 := __VDLType5Builder.Struct()
	__VDLType56 := __VDLType5Builder.Named("time.Time").AssignBase(__VDLType55)
	__VDLType57 := vdl.Int64Type
	__VDLType55.AppendField("Seconds", __VDLType57)
	__VDLType58 := vdl.Int32Type
	__VDLType55.AppendField("Nanos", __VDLType58)
	__VDLType52.AppendField("Timestamp", __VDLType56)
	__VDLType51.AssignElem(__VDLType53)
	__VDLType5Builder.Build()
	__VDLType5v, err := __VDLType51.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType5v
}
func init() {
	__VDLType5 = __VDLType5_gen()
}

var __VDLType1 *vdl.Type = vdl.TypeOf((*KDeviceCfg)(nil))
var __VDLType3 *vdl.Type = vdl.TypeOf((*KStreamDef)(nil))
var __VDLType4 *vdl.Type

func __VDLType4_gen() *vdl.Type {
	__VDLType4Builder := vdl.TypeBuilder{}

	__VDLType41 := __VDLType4Builder.Optional()
	__VDLType42 := __VDLType4Builder.Struct()
	__VDLType43 := __VDLType4Builder.Named("v.io/x/sensorlog/internal/sbmodel.SamplerDef").AssignBase(__VDLType42)
	__VDLType44 := vdl.StringType
	__VDLType42.AppendField("Script", __VDLType44)
	__VDLType45 := __VDLType4Builder.Struct()
	__VDLType46 := __VDLType4Builder.Named("time.Time").AssignBase(__VDLType45)
	__VDLType47 := vdl.Int64Type
	__VDLType45.AppendField("Seconds", __VDLType47)
	__VDLType48 := vdl.Int32Type
	__VDLType45.AppendField("Nanos", __VDLType48)
	__VDLType42.AppendField("Start", __VDLType46)
	__VDLType49 := __VDLType4Builder.Struct()
	__VDLType410 := __VDLType4Builder.Named("time.Duration").AssignBase(__VDLType49)
	__VDLType49.AppendField("Seconds", __VDLType47)
	__VDLType49.AppendField("Nanos", __VDLType48)
	__VDLType42.AppendField("Interval", __VDLType410)
	__VDLType41.AssignElem(__VDLType43)
	__VDLType4Builder.Build()
	__VDLType4v, err := __VDLType41.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType4v
}
func init() {
	__VDLType4 = __VDLType4_gen()
}

var __VDLType0 *vdl.Type = vdl.TypeOf((*VDeviceCfg)(nil))
var __VDLType2 *vdl.Type

func __VDLType2_gen() *vdl.Type {
	__VDLType2Builder := vdl.TypeBuilder{}

	__VDLType21 := __VDLType2Builder.Optional()
	__VDLType22 := __VDLType2Builder.Struct()
	__VDLType23 := __VDLType2Builder.Named("v.io/x/sensorlog/internal/sbmodel.VStreamDef").AssignBase(__VDLType22)
	__VDLType24 := vdl.StringType
	__VDLType22.AppendField("Desc", __VDLType24)
	__VDLType25 := __VDLType2Builder.Struct()
	__VDLType26 := __VDLType2Builder.Named("v.io/x/sensorlog/internal/sbmodel.SamplerDef").AssignBase(__VDLType25)
	__VDLType25.AppendField("Script", __VDLType24)
	__VDLType27 := __VDLType2Builder.Struct()
	__VDLType28 := __VDLType2Builder.Named("time.Time").AssignBase(__VDLType27)
	__VDLType29 := vdl.Int64Type
	__VDLType27.AppendField("Seconds", __VDLType29)
	__VDLType210 := vdl.Int32Type
	__VDLType27.AppendField("Nanos", __VDLType210)
	__VDLType25.AppendField("Start", __VDLType28)
	__VDLType211 := __VDLType2Builder.Struct()
	__VDLType212 := __VDLType2Builder.Named("time.Duration").AssignBase(__VDLType211)
	__VDLType211.AppendField("Seconds", __VDLType29)
	__VDLType211.AppendField("Nanos", __VDLType210)
	__VDLType25.AppendField("Interval", __VDLType212)
	__VDLType22.AppendField("Sampler", __VDLType26)
	__VDLType213 := vdl.BoolType
	__VDLType22.AppendField("Enabled", __VDLType213)
	__VDLType21.AssignElem(__VDLType23)
	__VDLType2Builder.Build()
	__VDLType2v, err := __VDLType21.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType2v
}
func init() {
	__VDLType2 = __VDLType2_gen()
}

var __VDLType_time_Duration *vdl.Type

func __VDLType_time_Duration_gen() *vdl.Type {
	__VDLType_time_DurationBuilder := vdl.TypeBuilder{}

	__VDLType_time_Duration1 := __VDLType_time_DurationBuilder.Struct()
	__VDLType_time_Duration2 := __VDLType_time_DurationBuilder.Named("time.Duration").AssignBase(__VDLType_time_Duration1)
	__VDLType_time_Duration3 := vdl.Int64Type
	__VDLType_time_Duration1.AppendField("Seconds", __VDLType_time_Duration3)
	__VDLType_time_Duration4 := vdl.Int32Type
	__VDLType_time_Duration1.AppendField("Nanos", __VDLType_time_Duration4)
	__VDLType_time_DurationBuilder.Build()
	__VDLType_time_Durationv, err := __VDLType_time_Duration2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_time_Durationv
}
func init() {
	__VDLType_time_Duration = __VDLType_time_Duration_gen()
}

var __VDLType_time_Time *vdl.Type

func __VDLType_time_Time_gen() *vdl.Type {
	__VDLType_time_TimeBuilder := vdl.TypeBuilder{}

	__VDLType_time_Time1 := __VDLType_time_TimeBuilder.Struct()
	__VDLType_time_Time2 := __VDLType_time_TimeBuilder.Named("time.Time").AssignBase(__VDLType_time_Time1)
	__VDLType_time_Time3 := vdl.Int64Type
	__VDLType_time_Time1.AppendField("Seconds", __VDLType_time_Time3)
	__VDLType_time_Time4 := vdl.Int32Type
	__VDLType_time_Time1.AppendField("Nanos", __VDLType_time_Time4)
	__VDLType_time_TimeBuilder.Build()
	__VDLType_time_Timev, err := __VDLType_time_Time2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_time_Timev
}
func init() {
	__VDLType_time_Time = __VDLType_time_Time_gen()
}

var __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint *vdl.Type

func __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint_gen() *vdl.Type {
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPointBuilder := vdl.TypeBuilder{}

	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint1 := __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPointBuilder.Struct()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint2 := __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPointBuilder.Named("v.io/x/sensorlog/internal/sbmodel.KDataPoint").AssignBase(__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint1)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint3 := vdl.StringType
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint1.AppendField("DevId", __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint3)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint1.AppendField("StreamId", __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint3)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint4 := __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPointBuilder.Struct()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint5 := __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPointBuilder.Named("time.Time").AssignBase(__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint4)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint6 := vdl.Int64Type
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint4.AppendField("Seconds", __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint6)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint7 := vdl.Int32Type
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint4.AppendField("Nanos", __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint7)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint1.AppendField("Timestamp", __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint5)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPointBuilder.Build()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPointv, err := __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPointv
}
func init() {
	__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint = __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint_gen()
}

var __VDLType_v_io_x_sensorlog_internal_sbmodel_KDeviceCfg *vdl.Type = vdl.TypeOf(KDeviceCfg{})
var __VDLType_v_io_x_sensorlog_internal_sbmodel_KStreamDef *vdl.Type = vdl.TypeOf(KStreamDef{})
var __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef *vdl.Type

func __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef_gen() *vdl.Type {
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDefBuilder := vdl.TypeBuilder{}

	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef1 := __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDefBuilder.Struct()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef2 := __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDefBuilder.Named("v.io/x/sensorlog/internal/sbmodel.SamplerDef").AssignBase(__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef1)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef3 := vdl.StringType
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef1.AppendField("Script", __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef3)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef4 := __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDefBuilder.Struct()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef5 := __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDefBuilder.Named("time.Time").AssignBase(__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef4)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef6 := vdl.Int64Type
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef4.AppendField("Seconds", __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef6)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef7 := vdl.Int32Type
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef4.AppendField("Nanos", __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef7)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef1.AppendField("Start", __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef5)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef8 := __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDefBuilder.Struct()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef9 := __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDefBuilder.Named("time.Duration").AssignBase(__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef8)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef8.AppendField("Seconds", __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef6)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef8.AppendField("Nanos", __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef7)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef1.AppendField("Interval", __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef9)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDefBuilder.Build()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDefv, err := __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDefv
}
func init() {
	__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef = __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef_gen()
}

var __VDLType_v_io_x_sensorlog_internal_sbmodel_VDataPoint *vdl.Type = vdl.TypeOf(VDataPoint(VDataPointValue{float64(0)}))
var __VDLType_v_io_x_sensorlog_internal_sbmodel_VDeviceCfg *vdl.Type = vdl.TypeOf(VDeviceCfg{})
var __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef *vdl.Type

func __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef_gen() *vdl.Type {
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefBuilder := vdl.TypeBuilder{}

	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef1 := __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefBuilder.Struct()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef2 := __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefBuilder.Named("v.io/x/sensorlog/internal/sbmodel.VStreamDef").AssignBase(__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef1)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef3 := vdl.StringType
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef1.AppendField("Desc", __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef3)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef4 := __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefBuilder.Struct()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef5 := __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefBuilder.Named("v.io/x/sensorlog/internal/sbmodel.SamplerDef").AssignBase(__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef4)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef4.AppendField("Script", __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef3)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef6 := __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefBuilder.Struct()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef7 := __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefBuilder.Named("time.Time").AssignBase(__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef6)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef8 := vdl.Int64Type
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef6.AppendField("Seconds", __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef8)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef9 := vdl.Int32Type
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef6.AppendField("Nanos", __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef9)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef4.AppendField("Start", __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef7)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef10 := __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefBuilder.Struct()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef11 := __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefBuilder.Named("time.Duration").AssignBase(__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef10)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef10.AppendField("Seconds", __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef8)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef10.AppendField("Nanos", __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef9)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef4.AppendField("Interval", __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef11)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef1.AppendField("Sampler", __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef5)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef12 := vdl.BoolType
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef1.AppendField("Enabled", __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef12)
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefBuilder.Build()
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefv, err := __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDefv
}
func init() {
	__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef = __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef_gen()
}
func __VDLEnsureNativeBuilt() {
	if __VDLType5 == nil {
		__VDLType5 = __VDLType5_gen()
	}
	if __VDLType4 == nil {
		__VDLType4 = __VDLType4_gen()
	}
	if __VDLType2 == nil {
		__VDLType2 = __VDLType2_gen()
	}
	if __VDLType_time_Duration == nil {
		__VDLType_time_Duration = __VDLType_time_Duration_gen()
	}
	if __VDLType_time_Time == nil {
		__VDLType_time_Time = __VDLType_time_Time_gen()
	}
	if __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint == nil {
		__VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint = __VDLType_v_io_x_sensorlog_internal_sbmodel_KDataPoint_gen()
	}
	if __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef == nil {
		__VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef = __VDLType_v_io_x_sensorlog_internal_sbmodel_SamplerDef_gen()
	}
	if __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef == nil {
		__VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef = __VDLType_v_io_x_sensorlog_internal_sbmodel_VStreamDef_gen()
	}
}