services/syncbase/nosql/types.vdl.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file was auto-generated by the vanadium vdl tool.
// Source: types.vdl

package nosql

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

// BatchOptions configures a batch.
// TODO(sadovsky): Add more options, e.g. to configure isolation, timeouts,
// whether to track the read set and/or write set, etc.
// TODO(sadovsky): Maybe add a DefaultBatchOptions() function that initializes
// BatchOptions with our desired defaults. Clients would be encouraged to
// initialize their BatchOptions object using that function and then modify it
// to their liking.
type BatchOptions struct {
	// Arbitrary string, typically used to describe the intent behind a batch.
	// Hints are surfaced to clients during conflict resolution.
	// TODO(sadovsky): Use "any" here?
	Hint string
	// ReadOnly specifies whether the batch should allow writes.
	// If ReadOnly is set to true, Abort() should be used to release any resources
	// associated with this batch (though it is not strictly required), and
	// Commit() will always fail.
	ReadOnly bool
}

func (BatchOptions) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.BatchOptions"`
}) {
}

func (m *BatchOptions) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_BatchOptions == nil || __VDLTypetypes0 == 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("Hint")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Hint), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("ReadOnly")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromBool(bool(m.ReadOnly), vdl.BoolType); 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 *BatchOptions) MakeVDLTarget() vdl.Target {
	return &BatchOptionsTarget{Value: m}
}

type BatchOptionsTarget struct {
	Value *BatchOptions
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

// PrefixPermissions represents a pair of (prefix, perms).
type PrefixPermissions struct {
	Prefix string
	Perms  access.Permissions
}

func (PrefixPermissions) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.PrefixPermissions"`
}) {
}

func (m *PrefixPermissions) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_PrefixPermissions == nil || __VDLTypetypes1 == 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("Prefix")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Prefix), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Perms")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Perms.FillVDLTarget(fieldTarget5, __VDLType_types_v_io_v23_security_access_Permissions); 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 *PrefixPermissions) MakeVDLTarget() vdl.Target {
	return &PrefixPermissionsTarget{Value: m}
}

type PrefixPermissionsTarget struct {
	Value *PrefixPermissions
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

// KeyValue is a key-value pair.
type KeyValue struct {
	Key   string
	Value []byte
}

func (KeyValue) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.KeyValue"`
}) {
}

func (m *KeyValue) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_KeyValue == nil || __VDLTypetypes2 == 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("Key")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Key), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Value")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := fieldTarget5.FromBytes([]byte(m.Value), __VDLTypetypes3); 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 *KeyValue) MakeVDLTarget() vdl.Target {
	return &KeyValueTarget{Value: m}
}

type KeyValueTarget struct {
	Value *KeyValue
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

// TableRow encapsulates the table name and row key or row prefix.
type TableRow struct {
	TableName string
	Row       string
}

func (TableRow) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.TableRow"`
}) {
}

func (m *TableRow) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_TableRow == nil || __VDLTypetypes4 == 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("TableName")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.TableName), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Row")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromString(string(m.Row), 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 *TableRow) MakeVDLTarget() vdl.Target {
	return &TableRowTarget{Value: m}
}

type TableRowTarget struct {
	Value *TableRow
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

// SyncgroupSpec contains the specification for a syncgroup.
type SyncgroupSpec struct {
	// Human-readable description of this syncgroup.
	Description string
	// Permissions governing access to this syncgroup.
	Perms access.Permissions
	// Data (tableName-rowPrefix pairs) covered by this syncgroup.
	Prefixes []TableRow
	// Mount tables at which to advertise this syncgroup, for rendezvous purposes.
	// (Note that in addition to these mount tables, Syncbase also uses
	// network-neighborhood-based discovery for rendezvous.)
	// We expect most clients to specify a single mount table, but we accept an
	// array of mount tables to permit the mount table to be changed over time
	// without disruption.
	// TODO(hpucha): Figure out a convention for advertising syncgroups in the
	// mount table.
	MountTables []string
	// Specifies the privacy of this syncgroup. More specifically, specifies
	// whether blobs in this syncgroup can be served to clients presenting
	// blobrefs obtained from other syncgroups.
	IsPrivate bool
}

func (SyncgroupSpec) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.SyncgroupSpec"`
}) {
}

func (m *SyncgroupSpec) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_SyncgroupSpec == nil || __VDLTypetypes5 == 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("Description")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Description), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Perms")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

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

		listTarget8, err := fieldTarget7.StartList(__VDLTypetypes6, len(m.Prefixes))
		if err != nil {
			return err
		}
		for i, elem10 := range m.Prefixes {
			elemTarget9, err := listTarget8.StartElem(i)
			if err != nil {
				return err
			}

			if err := elem10.FillVDLTarget(elemTarget9, __VDLType_types_v_io_v23_services_syncbase_nosql_TableRow); err != nil {
				return err
			}
			if err := listTarget8.FinishElem(elemTarget9); err != nil {
				return err
			}
		}
		if err := fieldTarget7.FinishList(listTarget8); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("MountTables")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		listTarget13, err := fieldTarget12.StartList(__VDLTypetypes7, len(m.MountTables))
		if err != nil {
			return err
		}
		for i, elem15 := range m.MountTables {
			elemTarget14, err := listTarget13.StartElem(i)
			if err != nil {
				return err
			}
			if err := elemTarget14.FromString(string(elem15), vdl.StringType); err != nil {
				return err
			}
			if err := listTarget13.FinishElem(elemTarget14); err != nil {
				return err
			}
		}
		if err := fieldTarget12.FinishList(listTarget13); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
			return err
		}
	}
	keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("IsPrivate")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget17.FromBool(bool(m.IsPrivate), vdl.BoolType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *SyncgroupSpec) MakeVDLTarget() vdl.Target {
	return &SyncgroupSpecTarget{Value: m}
}

type SyncgroupSpecTarget struct {
	Value *SyncgroupSpec
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *SyncgroupSpecTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_types_v_io_v23_services_syncbase_nosql_SyncgroupSpec) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_types_v_io_v23_services_syncbase_nosql_SyncgroupSpec)
	}
	return t, nil
}
func (t *SyncgroupSpecTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Description":
		val, err := &vdl.StringTarget{Value: &t.Value.Description}, error(nil)
		return nil, val, err
	case "Perms":
		val, err := &access.PermissionsTarget{Value: &t.Value.Perms}, error(nil)
		return nil, val, err
	case "Prefixes":
		val, err := &types5b5d762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e5461626c65526f77207374727563747b5461626c654e616d6520737472696e673b526f7720737472696e677dTarget{Value: &t.Value.Prefixes}, error(nil)
		return nil, val, err
	case "MountTables":
		val, err := &vdl.StringSliceTarget{Value: &t.Value.MountTables}, error(nil)
		return nil, val, err
	case "IsPrivate":
		val, err := &vdl.BoolTarget{Value: &t.Value.IsPrivate}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_types_v_io_v23_services_syncbase_nosql_SyncgroupSpec)
	}
}
func (t *SyncgroupSpecTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *SyncgroupSpecTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type types5b5d762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e5461626c65526f77207374727563747b5461626c654e616d6520737472696e673b526f7720737472696e677dTarget struct {
	Value *[]TableRow
	vdl.TargetBase
	vdl.ListTargetBase
}

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

	return nil
}

// SyncgroupMemberInfo contains per-member metadata.
type SyncgroupMemberInfo struct {
	SyncPriority byte
	IsServer     bool // This member should be given blob ownership preferentially.
}

func (SyncgroupMemberInfo) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.SyncgroupMemberInfo"`
}) {
}

func (m *SyncgroupMemberInfo) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_SyncgroupMemberInfo == nil || __VDLTypetypes8 == 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("SyncPriority")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromUint(uint64(m.SyncPriority), vdl.ByteType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("IsServer")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromBool(bool(m.IsServer), vdl.BoolType); 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 *SyncgroupMemberInfo) MakeVDLTarget() vdl.Target {
	return &SyncgroupMemberInfoTarget{Value: m}
}

type SyncgroupMemberInfoTarget struct {
	Value *SyncgroupMemberInfo
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

// ResolverType defines the possible conflict resolution policies.
// A Conflict is defined as presence of two independent sets of updates
// originating from the same version of an object. Syncbase
// uses version vectors to determine sequence of changes to a given row. Hence
// if device A updates a row with key "foo" from version V3 to V4, then syncs
// with device B which further updates the same row from version V4 to V5 and
// then V5 is synced back to device A, device A will see V5 as a forward
// progression of "foo" and not a conflict with V3 of "foo". But in the
// meantime if device A had already updated "foo" again from version V4 to
// version V6 then there is a conflict between V5 and V6 with V4 being the
// common ancestor.
type ResolverType int

const (
	ResolverTypeLastWins ResolverType = iota
	ResolverTypeAppResolves
	ResolverTypeDefer
)

// ResolverTypeAll holds all labels for ResolverType.
var ResolverTypeAll = [...]ResolverType{ResolverTypeLastWins, ResolverTypeAppResolves, ResolverTypeDefer}

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

// Set assigns label to x.
func (x *ResolverType) Set(label string) error {
	switch label {
	case "LastWins", "lastwins":
		*x = ResolverTypeLastWins
		return nil
	case "AppResolves", "appresolves":
		*x = ResolverTypeAppResolves
		return nil
	case "Defer", "defer":
		*x = ResolverTypeDefer
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in nosql.ResolverType", label)
}

// String returns the string label of x.
func (x ResolverType) String() string {
	switch x {
	case ResolverTypeLastWins:
		return "LastWins"
	case ResolverTypeAppResolves:
		return "AppResolves"
	case ResolverTypeDefer:
		return "Defer"
	}
	return ""
}

func (ResolverType) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.ResolverType"`
	Enum struct{ LastWins, AppResolves, Defer string }
}) {
}

func (m *ResolverType) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), __VDLType_types_v_io_v23_services_syncbase_nosql_ResolverType); err != nil {
		return err
	}
	return nil
}

func (m *ResolverType) MakeVDLTarget() vdl.Target {
	return &ResolverTypeTarget{Value: m}
}

type ResolverTypeTarget struct {
	Value *ResolverType
	vdl.TargetBase
}

func (t *ResolverTypeTarget) FromEnumLabel(src string, tt *vdl.Type) error {
	if !vdl.Compatible(tt, __VDLType_types_v_io_v23_services_syncbase_nosql_ResolverType) {
		return fmt.Errorf("type %v incompatible with %v", tt, __VDLType_types_v_io_v23_services_syncbase_nosql_ResolverType)
	}
	switch src {
	case "LastWins":
		*t.Value = 0
	case "AppResolves":
		*t.Value = 1
	case "Defer":
		*t.Value = 2
	default:
		return fmt.Errorf("label %s not in enum %v", src, __VDLType_types_v_io_v23_services_syncbase_nosql_ResolverType)
	}

	return nil
}

// ConflictInfo contains information to fully specify a conflict
// for a key, providing the (local, remote, ancestor) tuple.
// A key under conflict can be a part of a batch in local, remote or both
// updates. Since the batches can have more than one key, all ConflictInfos
// for the keys within the batches are grouped together into a single conflict
// batch and sent as a stream with the Continued field representing conflict
// batch boundaries.
type ConflictInfo struct {
	// Data is a unit chunk of ConflictInfo which can be sent over the conflict
	// stream.
	Data ConflictData
	// Continued represents whether the batch of ConflictInfos has ended.
	Continued bool
}

func (ConflictInfo) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.ConflictInfo"`
}) {
}

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

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Data")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		unionValue4 := m.Data
		if unionValue4 == nil {
			unionValue4 = ConflictDataBatch{}
		}
		if err := unionValue4.FillVDLTarget(fieldTarget3, __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Continued")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget6.FromBool(bool(m.Continued), vdl.BoolType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *ConflictInfo) MakeVDLTarget() vdl.Target {
	return &ConflictInfoTarget{Value: m}
}

type ConflictInfoTarget struct {
	Value *ConflictInfo
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ConflictInfoTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo)
	}
	return t, nil
}
func (t *ConflictInfoTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Data":
		val, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Data))
		return nil, val, err
	case "Continued":
		val, err := &vdl.BoolTarget{Value: &t.Value.Continued}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo)
	}
}
func (t *ConflictInfoTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ConflictInfoTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type (
	// ConflictData represents any single field of the ConflictData union type.
	//
	// ConflictData represents a unit of conflict data sent over the stream. It
	// can either contain information about a Batch or about an operation done
	// on a row.
	ConflictData 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 ConflictData union type.
		__VDLReflect(__ConflictDataReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
	}
	// ConflictDataBatch represents field Batch of the ConflictData union type.
	ConflictDataBatch struct{ Value BatchInfo }
	// ConflictDataRow represents field Row of the ConflictData union type.
	ConflictDataRow struct{ Value RowInfo }
	// __ConflictDataReflect describes the ConflictData union type.
	__ConflictDataReflect struct {
		Name  string `vdl:"v.io/v23/services/syncbase/nosql.ConflictData"`
		Type  ConflictData
		Union struct {
			Batch ConflictDataBatch
			Row   ConflictDataRow
		}
	}
)

func (x ConflictDataBatch) Index() int                         { return 0 }
func (x ConflictDataBatch) Interface() interface{}             { return x.Value }
func (x ConflictDataBatch) Name() string                       { return "Batch" }
func (x ConflictDataBatch) __VDLReflect(__ConflictDataReflect) {}

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

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

func (x ConflictDataRow) Index() int                         { return 1 }
func (x ConflictDataRow) Interface() interface{}             { return x.Value }
func (x ConflictDataRow) Name() string                       { return "Row" }
func (x ConflictDataRow) __VDLReflect(__ConflictDataReflect) {}

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

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

type BatchInfo struct {
	// Id is an identifier for a batch contained in a conflict. It is
	// unique only in the context of a given conflict. Its purpose is solely to
	// group one or more RowInfo objects together to represent a batch that
	// was committed by the client.
	Id uint64
	// Hint is the hint provided by the client when this batch was committed.
	Hint string
	// Source states where the batch comes from.
	Source BatchSource
}

func (BatchInfo) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.BatchInfo"`
}) {
}

func (m *BatchInfo) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_BatchInfo == nil || __VDLTypetypes10 == 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("Id")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromUint(uint64(m.Id), vdl.Uint64Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Hint")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromString(string(m.Hint), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Source")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Source.FillVDLTarget(fieldTarget7, __VDLType_types_v_io_v23_services_syncbase_nosql_BatchSource); 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 *BatchInfo) MakeVDLTarget() vdl.Target {
	return &BatchInfoTarget{Value: m}
}

type BatchInfoTarget struct {
	Value *BatchInfo
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

type BatchSourceTarget struct {
	Value *BatchSource
	vdl.TargetBase
}

func (t *BatchSourceTarget) FromEnumLabel(src string, tt *vdl.Type) error {
	if !vdl.Compatible(tt, __VDLType_types_v_io_v23_services_syncbase_nosql_BatchSource) {
		return fmt.Errorf("type %v incompatible with %v", tt, __VDLType_types_v_io_v23_services_syncbase_nosql_BatchSource)
	}
	switch src {
	case "Local":
		*t.Value = 0
	case "Remote":
		*t.Value = 1
	default:
		return fmt.Errorf("label %s not in enum %v", src, __VDLType_types_v_io_v23_services_syncbase_nosql_BatchSource)
	}

	return nil
}

// BatchSource represents where the batch was committed.
type BatchSource int

const (
	BatchSourceLocal BatchSource = iota
	BatchSourceRemote
)

// BatchSourceAll holds all labels for BatchSource.
var BatchSourceAll = [...]BatchSource{BatchSourceLocal, BatchSourceRemote}

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

// Set assigns label to x.
func (x *BatchSource) Set(label string) error {
	switch label {
	case "Local", "local":
		*x = BatchSourceLocal
		return nil
	case "Remote", "remote":
		*x = BatchSourceRemote
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in nosql.BatchSource", label)
}

// String returns the string label of x.
func (x BatchSource) String() string {
	switch x {
	case BatchSourceLocal:
		return "Local"
	case BatchSourceRemote:
		return "Remote"
	}
	return ""
}

func (BatchSource) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.BatchSource"`
	Enum struct{ Local, Remote string }
}) {
}

func (m *BatchSource) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), __VDLType_types_v_io_v23_services_syncbase_nosql_BatchSource); err != nil {
		return err
	}
	return nil
}

func (m *BatchSource) MakeVDLTarget() vdl.Target {
	return &BatchSourceTarget{Value: m}
}

// RowInfo contains a single operation performed on a row (in case of read or
// write) or a range or rows (in case of scan) along with a mapping to each
// of the batches that this operation belongs to.
// For example, if Row1 was updated on local syncbase conflicting with a write
// on remote syncbase as part of two separate batches, then it will be
// represented by a single RowInfo with Write Operation containing the
// respective local and remote values along with the batch id for both batches
// stored in the BatchIds field.
type RowInfo struct {
	// Op is a specific operation represented by RowInfo
	Op Operation
	// BatchIds contains ids of all batches that this RowInfo is a part of.
	BatchIds []uint64
}

func (RowInfo) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.RowInfo"`
}) {
}

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

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Op")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		unionValue4 := m.Op
		if unionValue4 == nil {
			unionValue4 = OperationRead{}
		}
		if err := unionValue4.FillVDLTarget(fieldTarget3, __VDLType_types_v_io_v23_services_syncbase_nosql_Operation); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("BatchIds")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		listTarget7, err := fieldTarget6.StartList(__VDLTypetypes12, len(m.BatchIds))
		if err != nil {
			return err
		}
		for i, elem9 := range m.BatchIds {
			elemTarget8, err := listTarget7.StartElem(i)
			if err != nil {
				return err
			}
			if err := elemTarget8.FromUint(uint64(elem9), vdl.Uint64Type); err != nil {
				return err
			}
			if err := listTarget7.FinishElem(elemTarget8); err != nil {
				return err
			}
		}
		if err := fieldTarget6.FinishList(listTarget7); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *RowInfo) MakeVDLTarget() vdl.Target {
	return &RowInfoTarget{Value: m}
}

type RowInfoTarget struct {
	Value *RowInfo
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *RowInfoTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo)
	}
	return t, nil
}
func (t *RowInfoTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Op":
		val, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Op))
		return nil, val, err
	case "BatchIds":
		val, err := &types5b5d75696e743634Target{Value: &t.Value.BatchIds}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo)
	}
}
func (t *RowInfoTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *RowInfoTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type types5b5d75696e743634Target struct {
	Value *[]uint64
	vdl.TargetBase
	vdl.ListTargetBase
}

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

	return nil
}

type (
	// Operation represents any single field of the Operation union type.
	//
	// Operation represents a specific operation on a row or a set of rows that is
	// a part of the conflict.
	Operation 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 Operation union type.
		__VDLReflect(__OperationReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
	}
	// OperationRead represents field Read of the Operation union type.
	//
	// Read represents a read operation performed on a specific row. For a given
	// row key there can only be at max one Read operation within a conflict.
	OperationRead struct{ Value RowOp }
	// OperationWrite represents field Write of the Operation union type.
	//
	// Write represents a write operation performed on a specific row. For a
	// given row key there can only be at max one Write operation within a
	// conflict.
	OperationWrite struct{ Value RowOp }
	// OperationScan represents field Scan of the Operation union type.
	//
	// Scan represents a scan operation performed over a specific range of keys.
	// For a given key range there can be at max one ScanOp within the Conflict.
	OperationScan struct{ Value ScanOp }
	// __OperationReflect describes the Operation union type.
	__OperationReflect struct {
		Name  string `vdl:"v.io/v23/services/syncbase/nosql.Operation"`
		Type  Operation
		Union struct {
			Read  OperationRead
			Write OperationWrite
			Scan  OperationScan
		}
	}
)

func (x OperationRead) Index() int                      { return 0 }
func (x OperationRead) Interface() interface{}          { return x.Value }
func (x OperationRead) Name() string                    { return "Read" }
func (x OperationRead) __VDLReflect(__OperationReflect) {}

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

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

func (x OperationWrite) Index() int                      { return 1 }
func (x OperationWrite) Interface() interface{}          { return x.Value }
func (x OperationWrite) Name() string                    { return "Write" }
func (x OperationWrite) __VDLReflect(__OperationReflect) {}

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

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

func (x OperationScan) Index() int                      { return 2 }
func (x OperationScan) Interface() interface{}          { return x.Value }
func (x OperationScan) Name() string                    { return "Scan" }
func (x OperationScan) __VDLReflect(__OperationReflect) {}

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

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

// RowOp represents a read or write operation on a row corresponding to the
// given key.
type RowOp struct {
	// The key under conflict.
	Key string
	// LocalValue contains the value read or written by local syncbase or nil.
	LocalValue *Value
	// RemoteValue contains the value read or written by remote syncbase or nil.
	RemoteValue *Value
	// AncestorValue contains the value for the key which is the lowest common
	// ancestor of the two values represented by LocalValue and RemoteValue or
	// nil if no ancestor exists or if the operation was read.
	AncestorValue *Value
}

func (RowOp) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.RowOp"`
}) {
}

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

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

		if m.LocalValue == nil {
			if err := fieldTarget5.FromNil(__VDLTypetypes14); err != nil {
				return err
			}
		} else {
			if err := m.LocalValue.FillVDLTarget(fieldTarget5, __VDLType_types_v_io_v23_services_syncbase_nosql_Value); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("RemoteValue")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.RemoteValue == nil {
			if err := fieldTarget7.FromNil(__VDLTypetypes14); err != nil {
				return err
			}
		} else {
			if err := m.RemoteValue.FillVDLTarget(fieldTarget7, __VDLType_types_v_io_v23_services_syncbase_nosql_Value); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("AncestorValue")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if m.AncestorValue == nil {
			if err := fieldTarget9.FromNil(__VDLTypetypes14); err != nil {
				return err
			}
		} else {
			if err := m.AncestorValue.FillVDLTarget(fieldTarget9, __VDLType_types_v_io_v23_services_syncbase_nosql_Value); 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 *RowOp) MakeVDLTarget() vdl.Target {
	return &RowOpTarget{Value: m}
}

type RowOpTarget struct {
	Value *RowOp
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

type types3f762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e56616c7565207374727563747b537461746520762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e56616c7565537461746520656e756d7b4578697374733b4e6f4578697374733b44656c657465643b556e6b6e6f776e7d3b4279746573205b5d627974653b577269746554732074696d652e54696d65207374727563747b5365636f6e647320696e7436343b4e616e6f7320696e7433327d7dTarget struct {
	Value **Value
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *types3f762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e56616c7565207374727563747b537461746520762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e56616c7565537461746520656e756d7b4578697374733b4e6f4578697374733b44656c657465643b556e6b6e6f776e7d3b4279746573205b5d627974653b577269746554732074696d652e54696d65207374727563747b5365636f6e647320696e7436343b4e616e6f7320696e7433327d7dTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if *t.Value == nil {
		*t.Value = &Value{}
	}
	target, err := &ValueTarget{Value: *t.Value}, error(nil)
	if err != nil {
		return nil, err
	}
	return target.StartFields(tt)
}
func (t *types3f762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e56616c7565207374727563747b537461746520762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e56616c7565537461746520656e756d7b4578697374733b4e6f4578697374733b44656c657465643b556e6b6e6f776e7d3b4279746573205b5d627974653b577269746554732074696d652e54696d65207374727563747b5365636f6e647320696e7436343b4e616e6f7320696e7433327d7dTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *types3f762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e56616c7565207374727563747b537461746520762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e56616c7565537461746520656e756d7b4578697374733b4e6f4578697374733b44656c657465643b556e6b6e6f776e7d3b4279746573205b5d627974653b577269746554732074696d652e54696d65207374727563747b5365636f6e647320696e7436343b4e616e6f7320696e7433327d7dTarget) FromNil(tt *vdl.Type) error {
	*t.Value = nil

	return nil
}

type ValueTarget struct {
	Value *Value
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ValueTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if !vdl.Compatible(tt, __VDLType_types_v_io_v23_services_syncbase_nosql_Value) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, __VDLType_types_v_io_v23_services_syncbase_nosql_Value)
	}
	return t, nil
}
func (t *ValueTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "State":
		val, err := &ValueStateTarget{Value: &t.Value.State}, error(nil)
		return nil, val, err
	case "Bytes":
		val, err := &vdl.BytesTarget{Value: &t.Value.Bytes}, error(nil)
		return nil, val, err
	case "WriteTs":
		val, err := &time_2.TimeTarget{Value: &t.Value.WriteTs}, error(nil)
		return nil, val, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct %v", name, __VDLType_types_v_io_v23_services_syncbase_nosql_Value)
	}
}
func (t *ValueTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ValueTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

type ValueStateTarget struct {
	Value *ValueState
	vdl.TargetBase
}

func (t *ValueStateTarget) FromEnumLabel(src string, tt *vdl.Type) error {
	if !vdl.Compatible(tt, __VDLType_types_v_io_v23_services_syncbase_nosql_ValueState) {
		return fmt.Errorf("type %v incompatible with %v", tt, __VDLType_types_v_io_v23_services_syncbase_nosql_ValueState)
	}
	switch src {
	case "Exists":
		*t.Value = 0
	case "NoExists":
		*t.Value = 1
	case "Deleted":
		*t.Value = 2
	case "Unknown":
		*t.Value = 3
	default:
		return fmt.Errorf("label %s not in enum %v", src, __VDLType_types_v_io_v23_services_syncbase_nosql_ValueState)
	}

	return nil
}

// ScanOp provides details of a scan operation.
type ScanOp struct {
	// Start contains the starting key for a range scan.
	Start string
	// Limit contains the end key for a range scan.
	Limit string
}

func (ScanOp) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.ScanOp"`
}) {
}

func (m *ScanOp) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_ScanOp == nil || __VDLTypetypes15 == 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("Start")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.Start), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Limit")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromString(string(m.Limit), 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 *ScanOp) MakeVDLTarget() vdl.Target {
	return &ScanOpTarget{Value: m}
}

type ScanOpTarget struct {
	Value *ScanOp
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

// Value contains the encoded bytes for a row's value stored in syncbase.
type Value struct {
	// State provides information about whether the field Bytes is empty or
	// not and if it is empty then why.
	State ValueState
	// VOM encoded bytes for a row's value or nil if the row was deleted.
	Bytes []byte
	// Write timestamp for this value
	WriteTs time.Time
}

func (Value) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.Value"`
}) {
}

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

	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("State")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.State.FillVDLTarget(fieldTarget3, __VDLType_types_v_io_v23_services_syncbase_nosql_ValueState); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Bytes")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := fieldTarget5.FromBytes([]byte(m.Bytes), __VDLTypetypes3); 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.WriteTs); err != nil {
		return err
	}

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

		if err := wireValue6.FillVDLTarget(fieldTarget8, __VDLType_types_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 *Value) MakeVDLTarget() vdl.Target {
	return &ValueTarget{Value: m}
}

// ValueState represents the state for Value object providing information about
// whether the Value object's Byte field is empty or not.
type ValueState int

const (
	ValueStateExists ValueState = iota
	ValueStateNoExists
	ValueStateDeleted
	ValueStateUnknown
)

// ValueStateAll holds all labels for ValueState.
var ValueStateAll = [...]ValueState{ValueStateExists, ValueStateNoExists, ValueStateDeleted, ValueStateUnknown}

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

// Set assigns label to x.
func (x *ValueState) Set(label string) error {
	switch label {
	case "Exists", "exists":
		*x = ValueStateExists
		return nil
	case "NoExists", "noexists":
		*x = ValueStateNoExists
		return nil
	case "Deleted", "deleted":
		*x = ValueStateDeleted
		return nil
	case "Unknown", "unknown":
		*x = ValueStateUnknown
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in nosql.ValueState", label)
}

// String returns the string label of x.
func (x ValueState) String() string {
	switch x {
	case ValueStateExists:
		return "Exists"
	case ValueStateNoExists:
		return "NoExists"
	case ValueStateDeleted:
		return "Deleted"
	case ValueStateUnknown:
		return "Unknown"
	}
	return ""
}

func (ValueState) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.ValueState"`
	Enum struct{ Exists, NoExists, Deleted, Unknown string }
}) {
}

func (m *ValueState) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), __VDLType_types_v_io_v23_services_syncbase_nosql_ValueState); err != nil {
		return err
	}
	return nil
}

func (m *ValueState) MakeVDLTarget() vdl.Target {
	return &ValueStateTarget{Value: m}
}

// ValueSelection represents the value that was selected as the final resolution
// for a conflict.
type ValueSelection int

const (
	ValueSelectionLocal ValueSelection = iota
	ValueSelectionRemote
	ValueSelectionOther
)

// ValueSelectionAll holds all labels for ValueSelection.
var ValueSelectionAll = [...]ValueSelection{ValueSelectionLocal, ValueSelectionRemote, ValueSelectionOther}

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

// Set assigns label to x.
func (x *ValueSelection) Set(label string) error {
	switch label {
	case "Local", "local":
		*x = ValueSelectionLocal
		return nil
	case "Remote", "remote":
		*x = ValueSelectionRemote
		return nil
	case "Other", "other":
		*x = ValueSelectionOther
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in nosql.ValueSelection", label)
}

// String returns the string label of x.
func (x ValueSelection) String() string {
	switch x {
	case ValueSelectionLocal:
		return "Local"
	case ValueSelectionRemote:
		return "Remote"
	case ValueSelectionOther:
		return "Other"
	}
	return ""
}

func (ValueSelection) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.ValueSelection"`
	Enum struct{ Local, Remote, Other string }
}) {
}

func (m *ValueSelection) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), __VDLType_types_v_io_v23_services_syncbase_nosql_ValueSelection); err != nil {
		return err
	}
	return nil
}

func (m *ValueSelection) MakeVDLTarget() vdl.Target {
	return &ValueSelectionTarget{Value: m}
}

type ValueSelectionTarget struct {
	Value *ValueSelection
	vdl.TargetBase
}

func (t *ValueSelectionTarget) FromEnumLabel(src string, tt *vdl.Type) error {
	if !vdl.Compatible(tt, __VDLType_types_v_io_v23_services_syncbase_nosql_ValueSelection) {
		return fmt.Errorf("type %v incompatible with %v", tt, __VDLType_types_v_io_v23_services_syncbase_nosql_ValueSelection)
	}
	switch src {
	case "Local":
		*t.Value = 0
	case "Remote":
		*t.Value = 1
	case "Other":
		*t.Value = 2
	default:
		return fmt.Errorf("label %s not in enum %v", src, __VDLType_types_v_io_v23_services_syncbase_nosql_ValueSelection)
	}

	return nil
}

// ResolutionInfo contains the application’s reply to a conflict for a key,
// providing the resolution value. The resolution may be over a group of keys
// in which case the application must send a stream of ResolutionInfos with
// the Continued field for the last ResolutionInfo representing the end of the
// batch with a value false. ResolutionInfos sent as part of a batch will be
// committed as a batch. If the commit fails, the Conflict will be re-sent.
type ResolutionInfo struct {
	// Key is the key under conflict.
	Key string
	// Selection represents the value that was selected as resolution.
	Selection ValueSelection
	// Result is the resolved value for the key. This field should be used only
	// if value of Selection field is 'Other'. If the result of a resolution is
	// delete for this key then add Value with nil Bytes.
	Result *Value
	// Continued represents whether the batch of ResolutionInfos has ended.
	Continued bool
}

func (ResolutionInfo) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.ResolutionInfo"`
}) {
}

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

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

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

		if m.Result == nil {
			if err := fieldTarget7.FromNil(__VDLTypetypes14); err != nil {
				return err
			}
		} else {
			if err := m.Result.FillVDLTarget(fieldTarget7, __VDLType_types_v_io_v23_services_syncbase_nosql_Value); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Continued")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget9.FromBool(bool(m.Continued), vdl.BoolType); 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 *ResolutionInfo) MakeVDLTarget() vdl.Target {
	return &ResolutionInfoTarget{Value: m}
}

type ResolutionInfoTarget struct {
	Value *ResolutionInfo
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

// SchemaMetadata maintains metadata related to the schema of a given database.
// There is one SchemaMetadata per database.
type SchemaMetadata struct {
	// Non negative Schema version number. Should be increased with every schema change
	// (e.g. adding fields to structs) that cannot be handled by previous
	// versions of the app.
	Version int32
	Policy  CrPolicy
}

func (SchemaMetadata) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.SchemaMetadata"`
}) {
}

func (m *SchemaMetadata) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_SchemaMetadata == nil || __VDLTypetypes17 == 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("Version")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromInt(int64(m.Version), vdl.Int32Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Policy")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Policy.FillVDLTarget(fieldTarget5, __VDLType_types_v_io_v23_services_syncbase_nosql_CrPolicy); 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 *SchemaMetadata) MakeVDLTarget() vdl.Target {
	return &SchemaMetadataTarget{Value: m}
}

type SchemaMetadataTarget struct {
	Value *SchemaMetadata
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

type CrPolicyTarget struct {
	Value *CrPolicy
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

type types5b5d762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e437252756c65207374727563747b5461626c654e616d6520737472696e673b4b657950726566697820737472696e673b5479706520737472696e673b5265736f6c76657220762e696f2f7632332f73657276696365732f73796e63626173652f6e6f73716c2e5265736f6c7665725479706520656e756d7b4c61737457696e733b4170705265736f6c7665733b44656665727d7dTarget struct {
	Value *[]CrRule
	vdl.TargetBase
	vdl.ListTargetBase
}

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

	return nil
}

type CrRuleTarget struct {
	Value *CrRule
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

// For a given row with a conflict, all rules are matched against the row.
// If no rules match the row, we default to "LastWins". If multiple
// rules match the row, ties are broken as follows:
//  1. If one match has a longer prefix than the other, take that one.
//  2. Else, if only one match specifies a type, take that one.
//  3. Else, the two matches are identical; take the last one in the Rules array.
type CrPolicy struct {
	Rules []CrRule
}

func (CrPolicy) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.CrPolicy"`
}) {
}

func (m *CrPolicy) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_CrPolicy == nil || __VDLTypetypes19 == 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("Rules")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		listTarget4, err := fieldTarget3.StartList(__VDLTypetypes18, len(m.Rules))
		if err != nil {
			return err
		}
		for i, elem6 := range m.Rules {
			elemTarget5, err := listTarget4.StartElem(i)
			if err != nil {
				return err
			}

			if err := elem6.FillVDLTarget(elemTarget5, __VDLType_types_v_io_v23_services_syncbase_nosql_CrRule); err != nil {
				return err
			}
			if err := listTarget4.FinishElem(elemTarget5); err != nil {
				return err
			}
		}
		if err := fieldTarget3.FinishList(listTarget4); 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 *CrPolicy) MakeVDLTarget() vdl.Target {
	return &CrPolicyTarget{Value: m}
}

// CrRule provides a filter and the type of resolution to perform for a row
// under conflict that passes the filter.
type CrRule struct {
	// TableName is the name of the table that this rule applies to.
	TableName string
	// KeyPrefix represents the set of keys within the given table for which
	// this policy applies. TableName must not be empty if this field is set.
	KeyPrefix string
	// Type includes the full package path for the value type for which this
	// policy applies.
	Type string
	// Policy for resolving conflict.
	Resolver ResolverType
}

func (CrRule) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.CrRule"`
}) {
}

func (m *CrRule) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_CrRule == nil || __VDLTypetypes20 == 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("TableName")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget3.FromString(string(m.TableName), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("KeyPrefix")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromString(string(m.KeyPrefix), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Type")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget7.FromString(string(m.Type), vdl.StringType); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
			return err
		}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Resolver")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.Resolver.FillVDLTarget(fieldTarget9, __VDLType_types_v_io_v23_services_syncbase_nosql_ResolverType); 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 *CrRule) MakeVDLTarget() vdl.Target {
	return &CrRuleTarget{Value: m}
}

// BlobRef is a reference to a blob.
type BlobRef string

func (BlobRef) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.BlobRef"`
}) {
}

func (m *BlobRef) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromString(string((*m)), __VDLType_types_v_io_v23_services_syncbase_nosql_BlobRef); err != nil {
		return err
	}
	return nil
}

func (m *BlobRef) MakeVDLTarget() vdl.Target {
	return &BlobRefTarget{Value: m}
}

type BlobRefTarget struct {
	Value *BlobRef
	vdl.TargetBase
}

func (t *BlobRefTarget) FromString(src string, tt *vdl.Type) error {
	if !vdl.Compatible(tt, __VDLType_types_v_io_v23_services_syncbase_nosql_BlobRef) {
		return fmt.Errorf("type %v incompatible with %v", tt, __VDLType_types_v_io_v23_services_syncbase_nosql_BlobRef)
	}
	*t.Value = BlobRef(src)

	return nil
}

// BlobFetchState represents the state transitions of a blob fetch.
type BlobFetchState int

const (
	BlobFetchStatePending BlobFetchState = iota
	BlobFetchStateLocating
	BlobFetchStateFetching
	BlobFetchStateDone
)

// BlobFetchStateAll holds all labels for BlobFetchState.
var BlobFetchStateAll = [...]BlobFetchState{BlobFetchStatePending, BlobFetchStateLocating, BlobFetchStateFetching, BlobFetchStateDone}

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

// Set assigns label to x.
func (x *BlobFetchState) Set(label string) error {
	switch label {
	case "Pending", "pending":
		*x = BlobFetchStatePending
		return nil
	case "Locating", "locating":
		*x = BlobFetchStateLocating
		return nil
	case "Fetching", "fetching":
		*x = BlobFetchStateFetching
		return nil
	case "Done", "done":
		*x = BlobFetchStateDone
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in nosql.BlobFetchState", label)
}

// String returns the string label of x.
func (x BlobFetchState) String() string {
	switch x {
	case BlobFetchStatePending:
		return "Pending"
	case BlobFetchStateLocating:
		return "Locating"
	case BlobFetchStateFetching:
		return "Fetching"
	case BlobFetchStateDone:
		return "Done"
	}
	return ""
}

func (BlobFetchState) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.BlobFetchState"`
	Enum struct{ Pending, Locating, Fetching, Done string }
}) {
}

func (m *BlobFetchState) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromEnumLabel((*m).String(), __VDLType_types_v_io_v23_services_syncbase_nosql_BlobFetchState); err != nil {
		return err
	}
	return nil
}

func (m *BlobFetchState) MakeVDLTarget() vdl.Target {
	return &BlobFetchStateTarget{Value: m}
}

type BlobFetchStateTarget struct {
	Value *BlobFetchState
	vdl.TargetBase
}

func (t *BlobFetchStateTarget) FromEnumLabel(src string, tt *vdl.Type) error {
	if !vdl.Compatible(tt, __VDLType_types_v_io_v23_services_syncbase_nosql_BlobFetchState) {
		return fmt.Errorf("type %v incompatible with %v", tt, __VDLType_types_v_io_v23_services_syncbase_nosql_BlobFetchState)
	}
	switch src {
	case "Pending":
		*t.Value = 0
	case "Locating":
		*t.Value = 1
	case "Fetching":
		*t.Value = 2
	case "Done":
		*t.Value = 3
	default:
		return fmt.Errorf("label %s not in enum %v", src, __VDLType_types_v_io_v23_services_syncbase_nosql_BlobFetchState)
	}

	return nil
}

// BlobFetchStatus describes the progress of an asynchronous blob fetch.
type BlobFetchStatus struct {
	State    BlobFetchState // State of the blob fetch request.
	Received int64          // Total number of bytes received.
	Total    int64          // Blob size.
}

func (BlobFetchStatus) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.BlobFetchStatus"`
}) {
}

func (m *BlobFetchStatus) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_BlobFetchStatus == nil || __VDLTypetypes21 == 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("State")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := m.State.FillVDLTarget(fieldTarget3, __VDLType_types_v_io_v23_services_syncbase_nosql_BlobFetchState); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Received")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromInt(int64(m.Received), vdl.Int64Type); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
			return err
		}
	}
	keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Total")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget7.FromInt(int64(m.Total), vdl.Int64Type); 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 *BlobFetchStatus) MakeVDLTarget() vdl.Target {
	return &BlobFetchStatusTarget{Value: m}
}

type BlobFetchStatusTarget struct {
	Value *BlobFetchStatus
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

// StoreChange is the new value for a watched entity.
// TODO(rogulenko): Consider adding the Shell state.
type StoreChange struct {
	// Value is the new value for the row if the Change state equals to Exists,
	// otherwise the Value is nil.
	Value []byte
	// FromSync indicates whether the change came from sync. If FromSync is
	// false, then the change originated from the local device.
	// Note: FromSync is always false for initial state Changes.
	FromSync bool
}

func (StoreChange) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/services/syncbase/nosql.StoreChange"`
}) {
}

func (m *StoreChange) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if __VDLType_types_v_io_v23_services_syncbase_nosql_StoreChange == nil || __VDLTypetypes22 == 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("Value")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		if err := fieldTarget3.FromBytes([]byte(m.Value), __VDLTypetypes3); err != nil {
			return err
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("FromSync")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {
		if err := fieldTarget5.FromBool(bool(m.FromSync), vdl.BoolType); 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 *StoreChange) MakeVDLTarget() vdl.Target {
	return &StoreChangeTarget{Value: m}
}

type StoreChangeTarget struct {
	Value *StoreChange
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	return nil
}

func init() {
	vdl.Register((*BatchOptions)(nil))
	vdl.Register((*PrefixPermissions)(nil))
	vdl.Register((*KeyValue)(nil))
	vdl.Register((*TableRow)(nil))
	vdl.Register((*SyncgroupSpec)(nil))
	vdl.Register((*SyncgroupMemberInfo)(nil))
	vdl.Register((*ResolverType)(nil))
	vdl.Register((*ConflictInfo)(nil))
	vdl.Register((*ConflictData)(nil))
	vdl.Register((*BatchInfo)(nil))
	vdl.Register((*BatchSource)(nil))
	vdl.Register((*RowInfo)(nil))
	vdl.Register((*Operation)(nil))
	vdl.Register((*RowOp)(nil))
	vdl.Register((*ScanOp)(nil))
	vdl.Register((*Value)(nil))
	vdl.Register((*ValueState)(nil))
	vdl.Register((*ValueSelection)(nil))
	vdl.Register((*ResolutionInfo)(nil))
	vdl.Register((*SchemaMetadata)(nil))
	vdl.Register((*CrPolicy)(nil))
	vdl.Register((*CrRule)(nil))
	vdl.Register((*BlobRef)(nil))
	vdl.Register((*BlobFetchState)(nil))
	vdl.Register((*BlobFetchStatus)(nil))
	vdl.Register((*StoreChange)(nil))
}

var __VDLTypetypes10 *vdl.Type = vdl.TypeOf((*BatchInfo)(nil))
var __VDLTypetypes0 *vdl.Type = vdl.TypeOf((*BatchOptions)(nil))
var __VDLTypetypes21 *vdl.Type = vdl.TypeOf((*BlobFetchStatus)(nil))
var __VDLTypetypes9 *vdl.Type

func __VDLTypetypes9_gen() *vdl.Type {
	__VDLTypetypes9Builder := vdl.TypeBuilder{}

	__VDLTypetypes91 := __VDLTypetypes9Builder.Optional()
	__VDLTypetypes92 := __VDLTypetypes9Builder.Struct()
	__VDLTypetypes93 := __VDLTypetypes9Builder.Named("v.io/v23/services/syncbase/nosql.ConflictInfo").AssignBase(__VDLTypetypes92)
	__VDLTypetypes94 := __VDLTypetypes9Builder.Union()
	__VDLTypetypes95 := __VDLTypetypes9Builder.Named("v.io/v23/services/syncbase/nosql.ConflictData").AssignBase(__VDLTypetypes94)
	__VDLTypetypes96 := __VDLTypetypes9Builder.Struct()
	__VDLTypetypes97 := __VDLTypetypes9Builder.Named("v.io/v23/services/syncbase/nosql.BatchInfo").AssignBase(__VDLTypetypes96)
	__VDLTypetypes98 := vdl.Uint64Type
	__VDLTypetypes96.AppendField("Id", __VDLTypetypes98)
	__VDLTypetypes99 := vdl.StringType
	__VDLTypetypes96.AppendField("Hint", __VDLTypetypes99)
	__VDLTypetypes910 := __VDLTypetypes9Builder.Enum()
	__VDLTypetypes911 := __VDLTypetypes9Builder.Named("v.io/v23/services/syncbase/nosql.BatchSource").AssignBase(__VDLTypetypes910)
	__VDLTypetypes910.AppendLabel("Local")
	__VDLTypetypes910.AppendLabel("Remote")
	__VDLTypetypes96.AppendField("Source", __VDLTypetypes911)
	__VDLTypetypes94.AppendField("Batch", __VDLTypetypes97)
	__VDLTypetypes912 := __VDLTypetypes9Builder.Struct()
	__VDLTypetypes913 := __VDLTypetypes9Builder.Named("v.io/v23/services/syncbase/nosql.RowInfo").AssignBase(__VDLTypetypes912)
	__VDLTypetypes914 := __VDLTypetypes9Builder.Union()
	__VDLTypetypes915 := __VDLTypetypes9Builder.Named("v.io/v23/services/syncbase/nosql.Operation").AssignBase(__VDLTypetypes914)
	__VDLTypetypes916 := __VDLTypetypes9Builder.Struct()
	__VDLTypetypes917 := __VDLTypetypes9Builder.Named("v.io/v23/services/syncbase/nosql.RowOp").AssignBase(__VDLTypetypes916)
	__VDLTypetypes916.AppendField("Key", __VDLTypetypes99)
	__VDLTypetypes918 := __VDLTypetypes9Builder.Optional()
	__VDLTypetypes919 := __VDLTypetypes9Builder.Struct()
	__VDLTypetypes920 := __VDLTypetypes9Builder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLTypetypes919)
	__VDLTypetypes921 := __VDLTypetypes9Builder.Enum()
	__VDLTypetypes922 := __VDLTypetypes9Builder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLTypetypes921)
	__VDLTypetypes921.AppendLabel("Exists")
	__VDLTypetypes921.AppendLabel("NoExists")
	__VDLTypetypes921.AppendLabel("Deleted")
	__VDLTypetypes921.AppendLabel("Unknown")
	__VDLTypetypes919.AppendField("State", __VDLTypetypes922)
	__VDLTypetypes923 := __VDLTypetypes9Builder.List()
	__VDLTypetypes924 := vdl.ByteType
	__VDLTypetypes923.AssignElem(__VDLTypetypes924)
	__VDLTypetypes919.AppendField("Bytes", __VDLTypetypes923)
	__VDLTypetypes925 := __VDLTypetypes9Builder.Struct()
	__VDLTypetypes926 := __VDLTypetypes9Builder.Named("time.Time").AssignBase(__VDLTypetypes925)
	__VDLTypetypes927 := vdl.Int64Type
	__VDLTypetypes925.AppendField("Seconds", __VDLTypetypes927)
	__VDLTypetypes928 := vdl.Int32Type
	__VDLTypetypes925.AppendField("Nanos", __VDLTypetypes928)
	__VDLTypetypes919.AppendField("WriteTs", __VDLTypetypes926)
	__VDLTypetypes918.AssignElem(__VDLTypetypes920)
	__VDLTypetypes916.AppendField("LocalValue", __VDLTypetypes918)
	__VDLTypetypes916.AppendField("RemoteValue", __VDLTypetypes918)
	__VDLTypetypes916.AppendField("AncestorValue", __VDLTypetypes918)
	__VDLTypetypes914.AppendField("Read", __VDLTypetypes917)
	__VDLTypetypes914.AppendField("Write", __VDLTypetypes917)
	__VDLTypetypes929 := __VDLTypetypes9Builder.Struct()
	__VDLTypetypes930 := __VDLTypetypes9Builder.Named("v.io/v23/services/syncbase/nosql.ScanOp").AssignBase(__VDLTypetypes929)
	__VDLTypetypes929.AppendField("Start", __VDLTypetypes99)
	__VDLTypetypes929.AppendField("Limit", __VDLTypetypes99)
	__VDLTypetypes914.AppendField("Scan", __VDLTypetypes930)
	__VDLTypetypes912.AppendField("Op", __VDLTypetypes915)
	__VDLTypetypes931 := __VDLTypetypes9Builder.List()
	__VDLTypetypes931.AssignElem(__VDLTypetypes98)
	__VDLTypetypes912.AppendField("BatchIds", __VDLTypetypes931)
	__VDLTypetypes94.AppendField("Row", __VDLTypetypes913)
	__VDLTypetypes92.AppendField("Data", __VDLTypetypes95)
	__VDLTypetypes932 := vdl.BoolType
	__VDLTypetypes92.AppendField("Continued", __VDLTypetypes932)
	__VDLTypetypes91.AssignElem(__VDLTypetypes93)
	__VDLTypetypes9Builder.Build()
	__VDLTypetypes9v, err := __VDLTypetypes91.Built()
	if err != nil {
		panic(err)
	}
	return __VDLTypetypes9v
}
func init() {
	__VDLTypetypes9 = __VDLTypetypes9_gen()
}

var __VDLTypetypes19 *vdl.Type = vdl.TypeOf((*CrPolicy)(nil))
var __VDLTypetypes20 *vdl.Type = vdl.TypeOf((*CrRule)(nil))
var __VDLTypetypes2 *vdl.Type = vdl.TypeOf((*KeyValue)(nil))
var __VDLTypetypes1 *vdl.Type = vdl.TypeOf((*PrefixPermissions)(nil))
var __VDLTypetypes16 *vdl.Type

func __VDLTypetypes16_gen() *vdl.Type {
	__VDLTypetypes16Builder := vdl.TypeBuilder{}

	__VDLTypetypes161 := __VDLTypetypes16Builder.Optional()
	__VDLTypetypes162 := __VDLTypetypes16Builder.Struct()
	__VDLTypetypes163 := __VDLTypetypes16Builder.Named("v.io/v23/services/syncbase/nosql.ResolutionInfo").AssignBase(__VDLTypetypes162)
	__VDLTypetypes164 := vdl.StringType
	__VDLTypetypes162.AppendField("Key", __VDLTypetypes164)
	__VDLTypetypes165 := __VDLTypetypes16Builder.Enum()
	__VDLTypetypes166 := __VDLTypetypes16Builder.Named("v.io/v23/services/syncbase/nosql.ValueSelection").AssignBase(__VDLTypetypes165)
	__VDLTypetypes165.AppendLabel("Local")
	__VDLTypetypes165.AppendLabel("Remote")
	__VDLTypetypes165.AppendLabel("Other")
	__VDLTypetypes162.AppendField("Selection", __VDLTypetypes166)
	__VDLTypetypes167 := __VDLTypetypes16Builder.Optional()
	__VDLTypetypes168 := __VDLTypetypes16Builder.Struct()
	__VDLTypetypes169 := __VDLTypetypes16Builder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLTypetypes168)
	__VDLTypetypes1610 := __VDLTypetypes16Builder.Enum()
	__VDLTypetypes1611 := __VDLTypetypes16Builder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLTypetypes1610)
	__VDLTypetypes1610.AppendLabel("Exists")
	__VDLTypetypes1610.AppendLabel("NoExists")
	__VDLTypetypes1610.AppendLabel("Deleted")
	__VDLTypetypes1610.AppendLabel("Unknown")
	__VDLTypetypes168.AppendField("State", __VDLTypetypes1611)
	__VDLTypetypes1612 := __VDLTypetypes16Builder.List()
	__VDLTypetypes1613 := vdl.ByteType
	__VDLTypetypes1612.AssignElem(__VDLTypetypes1613)
	__VDLTypetypes168.AppendField("Bytes", __VDLTypetypes1612)
	__VDLTypetypes1614 := __VDLTypetypes16Builder.Struct()
	__VDLTypetypes1615 := __VDLTypetypes16Builder.Named("time.Time").AssignBase(__VDLTypetypes1614)
	__VDLTypetypes1616 := vdl.Int64Type
	__VDLTypetypes1614.AppendField("Seconds", __VDLTypetypes1616)
	__VDLTypetypes1617 := vdl.Int32Type
	__VDLTypetypes1614.AppendField("Nanos", __VDLTypetypes1617)
	__VDLTypetypes168.AppendField("WriteTs", __VDLTypetypes1615)
	__VDLTypetypes167.AssignElem(__VDLTypetypes169)
	__VDLTypetypes162.AppendField("Result", __VDLTypetypes167)
	__VDLTypetypes1618 := vdl.BoolType
	__VDLTypetypes162.AppendField("Continued", __VDLTypetypes1618)
	__VDLTypetypes161.AssignElem(__VDLTypetypes163)
	__VDLTypetypes16Builder.Build()
	__VDLTypetypes16v, err := __VDLTypetypes161.Built()
	if err != nil {
		panic(err)
	}
	return __VDLTypetypes16v
}
func init() {
	__VDLTypetypes16 = __VDLTypetypes16_gen()
}

var __VDLTypetypes11 *vdl.Type

func __VDLTypetypes11_gen() *vdl.Type {
	__VDLTypetypes11Builder := vdl.TypeBuilder{}

	__VDLTypetypes111 := __VDLTypetypes11Builder.Optional()
	__VDLTypetypes112 := __VDLTypetypes11Builder.Struct()
	__VDLTypetypes113 := __VDLTypetypes11Builder.Named("v.io/v23/services/syncbase/nosql.RowInfo").AssignBase(__VDLTypetypes112)
	__VDLTypetypes114 := __VDLTypetypes11Builder.Union()
	__VDLTypetypes115 := __VDLTypetypes11Builder.Named("v.io/v23/services/syncbase/nosql.Operation").AssignBase(__VDLTypetypes114)
	__VDLTypetypes116 := __VDLTypetypes11Builder.Struct()
	__VDLTypetypes117 := __VDLTypetypes11Builder.Named("v.io/v23/services/syncbase/nosql.RowOp").AssignBase(__VDLTypetypes116)
	__VDLTypetypes118 := vdl.StringType
	__VDLTypetypes116.AppendField("Key", __VDLTypetypes118)
	__VDLTypetypes119 := __VDLTypetypes11Builder.Optional()
	__VDLTypetypes1110 := __VDLTypetypes11Builder.Struct()
	__VDLTypetypes1111 := __VDLTypetypes11Builder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLTypetypes1110)
	__VDLTypetypes1112 := __VDLTypetypes11Builder.Enum()
	__VDLTypetypes1113 := __VDLTypetypes11Builder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLTypetypes1112)
	__VDLTypetypes1112.AppendLabel("Exists")
	__VDLTypetypes1112.AppendLabel("NoExists")
	__VDLTypetypes1112.AppendLabel("Deleted")
	__VDLTypetypes1112.AppendLabel("Unknown")
	__VDLTypetypes1110.AppendField("State", __VDLTypetypes1113)
	__VDLTypetypes1114 := __VDLTypetypes11Builder.List()
	__VDLTypetypes1115 := vdl.ByteType
	__VDLTypetypes1114.AssignElem(__VDLTypetypes1115)
	__VDLTypetypes1110.AppendField("Bytes", __VDLTypetypes1114)
	__VDLTypetypes1116 := __VDLTypetypes11Builder.Struct()
	__VDLTypetypes1117 := __VDLTypetypes11Builder.Named("time.Time").AssignBase(__VDLTypetypes1116)
	__VDLTypetypes1118 := vdl.Int64Type
	__VDLTypetypes1116.AppendField("Seconds", __VDLTypetypes1118)
	__VDLTypetypes1119 := vdl.Int32Type
	__VDLTypetypes1116.AppendField("Nanos", __VDLTypetypes1119)
	__VDLTypetypes1110.AppendField("WriteTs", __VDLTypetypes1117)
	__VDLTypetypes119.AssignElem(__VDLTypetypes1111)
	__VDLTypetypes116.AppendField("LocalValue", __VDLTypetypes119)
	__VDLTypetypes116.AppendField("RemoteValue", __VDLTypetypes119)
	__VDLTypetypes116.AppendField("AncestorValue", __VDLTypetypes119)
	__VDLTypetypes114.AppendField("Read", __VDLTypetypes117)
	__VDLTypetypes114.AppendField("Write", __VDLTypetypes117)
	__VDLTypetypes1120 := __VDLTypetypes11Builder.Struct()
	__VDLTypetypes1121 := __VDLTypetypes11Builder.Named("v.io/v23/services/syncbase/nosql.ScanOp").AssignBase(__VDLTypetypes1120)
	__VDLTypetypes1120.AppendField("Start", __VDLTypetypes118)
	__VDLTypetypes1120.AppendField("Limit", __VDLTypetypes118)
	__VDLTypetypes114.AppendField("Scan", __VDLTypetypes1121)
	__VDLTypetypes112.AppendField("Op", __VDLTypetypes115)
	__VDLTypetypes1122 := __VDLTypetypes11Builder.List()
	__VDLTypetypes1123 := vdl.Uint64Type
	__VDLTypetypes1122.AssignElem(__VDLTypetypes1123)
	__VDLTypetypes112.AppendField("BatchIds", __VDLTypetypes1122)
	__VDLTypetypes111.AssignElem(__VDLTypetypes113)
	__VDLTypetypes11Builder.Build()
	__VDLTypetypes11v, err := __VDLTypetypes111.Built()
	if err != nil {
		panic(err)
	}
	return __VDLTypetypes11v
}
func init() {
	__VDLTypetypes11 = __VDLTypetypes11_gen()
}

var __VDLTypetypes13 *vdl.Type

func __VDLTypetypes13_gen() *vdl.Type {
	__VDLTypetypes13Builder := vdl.TypeBuilder{}

	__VDLTypetypes131 := __VDLTypetypes13Builder.Optional()
	__VDLTypetypes132 := __VDLTypetypes13Builder.Struct()
	__VDLTypetypes133 := __VDLTypetypes13Builder.Named("v.io/v23/services/syncbase/nosql.RowOp").AssignBase(__VDLTypetypes132)
	__VDLTypetypes134 := vdl.StringType
	__VDLTypetypes132.AppendField("Key", __VDLTypetypes134)
	__VDLTypetypes135 := __VDLTypetypes13Builder.Optional()
	__VDLTypetypes136 := __VDLTypetypes13Builder.Struct()
	__VDLTypetypes137 := __VDLTypetypes13Builder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLTypetypes136)
	__VDLTypetypes138 := __VDLTypetypes13Builder.Enum()
	__VDLTypetypes139 := __VDLTypetypes13Builder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLTypetypes138)
	__VDLTypetypes138.AppendLabel("Exists")
	__VDLTypetypes138.AppendLabel("NoExists")
	__VDLTypetypes138.AppendLabel("Deleted")
	__VDLTypetypes138.AppendLabel("Unknown")
	__VDLTypetypes136.AppendField("State", __VDLTypetypes139)
	__VDLTypetypes1310 := __VDLTypetypes13Builder.List()
	__VDLTypetypes1311 := vdl.ByteType
	__VDLTypetypes1310.AssignElem(__VDLTypetypes1311)
	__VDLTypetypes136.AppendField("Bytes", __VDLTypetypes1310)
	__VDLTypetypes1312 := __VDLTypetypes13Builder.Struct()
	__VDLTypetypes1313 := __VDLTypetypes13Builder.Named("time.Time").AssignBase(__VDLTypetypes1312)
	__VDLTypetypes1314 := vdl.Int64Type
	__VDLTypetypes1312.AppendField("Seconds", __VDLTypetypes1314)
	__VDLTypetypes1315 := vdl.Int32Type
	__VDLTypetypes1312.AppendField("Nanos", __VDLTypetypes1315)
	__VDLTypetypes136.AppendField("WriteTs", __VDLTypetypes1313)
	__VDLTypetypes135.AssignElem(__VDLTypetypes137)
	__VDLTypetypes132.AppendField("LocalValue", __VDLTypetypes135)
	__VDLTypetypes132.AppendField("RemoteValue", __VDLTypetypes135)
	__VDLTypetypes132.AppendField("AncestorValue", __VDLTypetypes135)
	__VDLTypetypes131.AssignElem(__VDLTypetypes133)
	__VDLTypetypes13Builder.Build()
	__VDLTypetypes13v, err := __VDLTypetypes131.Built()
	if err != nil {
		panic(err)
	}
	return __VDLTypetypes13v
}
func init() {
	__VDLTypetypes13 = __VDLTypetypes13_gen()
}

var __VDLTypetypes15 *vdl.Type = vdl.TypeOf((*ScanOp)(nil))
var __VDLTypetypes17 *vdl.Type = vdl.TypeOf((*SchemaMetadata)(nil))
var __VDLTypetypes22 *vdl.Type = vdl.TypeOf((*StoreChange)(nil))
var __VDLTypetypes8 *vdl.Type = vdl.TypeOf((*SyncgroupMemberInfo)(nil))
var __VDLTypetypes5 *vdl.Type = vdl.TypeOf((*SyncgroupSpec)(nil))
var __VDLTypetypes4 *vdl.Type = vdl.TypeOf((*TableRow)(nil))
var __VDLTypetypes14 *vdl.Type

func __VDLTypetypes14_gen() *vdl.Type {
	__VDLTypetypes14Builder := vdl.TypeBuilder{}

	__VDLTypetypes141 := __VDLTypetypes14Builder.Optional()
	__VDLTypetypes142 := __VDLTypetypes14Builder.Struct()
	__VDLTypetypes143 := __VDLTypetypes14Builder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLTypetypes142)
	__VDLTypetypes144 := __VDLTypetypes14Builder.Enum()
	__VDLTypetypes145 := __VDLTypetypes14Builder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLTypetypes144)
	__VDLTypetypes144.AppendLabel("Exists")
	__VDLTypetypes144.AppendLabel("NoExists")
	__VDLTypetypes144.AppendLabel("Deleted")
	__VDLTypetypes144.AppendLabel("Unknown")
	__VDLTypetypes142.AppendField("State", __VDLTypetypes145)
	__VDLTypetypes146 := __VDLTypetypes14Builder.List()
	__VDLTypetypes147 := vdl.ByteType
	__VDLTypetypes146.AssignElem(__VDLTypetypes147)
	__VDLTypetypes142.AppendField("Bytes", __VDLTypetypes146)
	__VDLTypetypes148 := __VDLTypetypes14Builder.Struct()
	__VDLTypetypes149 := __VDLTypetypes14Builder.Named("time.Time").AssignBase(__VDLTypetypes148)
	__VDLTypetypes1410 := vdl.Int64Type
	__VDLTypetypes148.AppendField("Seconds", __VDLTypetypes1410)
	__VDLTypetypes1411 := vdl.Int32Type
	__VDLTypetypes148.AppendField("Nanos", __VDLTypetypes1411)
	__VDLTypetypes142.AppendField("WriteTs", __VDLTypetypes149)
	__VDLTypetypes141.AssignElem(__VDLTypetypes143)
	__VDLTypetypes14Builder.Build()
	__VDLTypetypes14v, err := __VDLTypetypes141.Built()
	if err != nil {
		panic(err)
	}
	return __VDLTypetypes14v
}
func init() {
	__VDLTypetypes14 = __VDLTypetypes14_gen()
}

var __VDLTypetypes3 *vdl.Type = vdl.TypeOf([]byte(nil))
var __VDLTypetypes7 *vdl.Type = vdl.TypeOf([]string(nil))
var __VDLTypetypes12 *vdl.Type = vdl.TypeOf([]uint64(nil))
var __VDLTypetypes18 *vdl.Type = vdl.TypeOf([]CrRule(nil))
var __VDLTypetypes6 *vdl.Type = vdl.TypeOf([]TableRow(nil))
var __VDLType_types_time_Time *vdl.Type

func __VDLType_types_time_Time_gen() *vdl.Type {
	__VDLType_types_time_TimeBuilder := vdl.TypeBuilder{}

	__VDLType_types_time_Time1 := __VDLType_types_time_TimeBuilder.Struct()
	__VDLType_types_time_Time2 := __VDLType_types_time_TimeBuilder.Named("time.Time").AssignBase(__VDLType_types_time_Time1)
	__VDLType_types_time_Time3 := vdl.Int64Type
	__VDLType_types_time_Time1.AppendField("Seconds", __VDLType_types_time_Time3)
	__VDLType_types_time_Time4 := vdl.Int32Type
	__VDLType_types_time_Time1.AppendField("Nanos", __VDLType_types_time_Time4)
	__VDLType_types_time_TimeBuilder.Build()
	__VDLType_types_time_Timev, err := __VDLType_types_time_Time2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_types_time_Timev
}
func init() {
	__VDLType_types_time_Time = __VDLType_types_time_Time_gen()
}

var __VDLType_types_v_io_v23_security_access_Permissions *vdl.Type = vdl.TypeOf(access.Permissions(nil))
var __VDLType_types_v_io_v23_services_syncbase_nosql_BatchInfo *vdl.Type = vdl.TypeOf(BatchInfo{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_BatchOptions *vdl.Type = vdl.TypeOf(BatchOptions{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_BatchSource *vdl.Type = vdl.TypeOf(BatchSourceLocal)
var __VDLType_types_v_io_v23_services_syncbase_nosql_BlobFetchState *vdl.Type = vdl.TypeOf(BlobFetchStatePending)
var __VDLType_types_v_io_v23_services_syncbase_nosql_BlobFetchStatus *vdl.Type = vdl.TypeOf(BlobFetchStatus{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_BlobRef *vdl.Type = vdl.TypeOf(BlobRef(""))
var __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData *vdl.Type

func __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData_gen() *vdl.Type {
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder := vdl.TypeBuilder{}

	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData1 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Union()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData2 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Named("v.io/v23/services/syncbase/nosql.ConflictData").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData1)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData3 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData4 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Named("v.io/v23/services/syncbase/nosql.BatchInfo").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData3)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData5 := vdl.Uint64Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData3.AppendField("Id", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData5)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData6 := vdl.StringType
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData3.AppendField("Hint", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData7 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Enum()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData8 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Named("v.io/v23/services/syncbase/nosql.BatchSource").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData7)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData7.AppendLabel("Local")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData7.AppendLabel("Remote")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData3.AppendField("Source", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData1.AppendField("Batch", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData4)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData9 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData10 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Named("v.io/v23/services/syncbase/nosql.RowInfo").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData9)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData11 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Union()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData12 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Named("v.io/v23/services/syncbase/nosql.Operation").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData11)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData13 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData14 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Named("v.io/v23/services/syncbase/nosql.RowOp").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData13)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData13.AppendField("Key", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData15 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Optional()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData16 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData17 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData16)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData18 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Enum()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData19 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData18)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData18.AppendLabel("Exists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData18.AppendLabel("NoExists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData18.AppendLabel("Deleted")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData18.AppendLabel("Unknown")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData16.AppendField("State", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData19)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData20 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.List()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData21 := vdl.ByteType
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData20.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData21)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData16.AppendField("Bytes", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData20)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData22 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData23 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Named("time.Time").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData22)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData24 := vdl.Int64Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData22.AppendField("Seconds", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData24)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData25 := vdl.Int32Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData22.AppendField("Nanos", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData25)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData16.AppendField("WriteTs", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData23)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData15.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData17)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData13.AppendField("LocalValue", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData15)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData13.AppendField("RemoteValue", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData15)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData13.AppendField("AncestorValue", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData15)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData11.AppendField("Read", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData14)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData11.AppendField("Write", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData14)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData26 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData27 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Named("v.io/v23/services/syncbase/nosql.ScanOp").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData26)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData26.AppendField("Start", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData26.AppendField("Limit", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData11.AppendField("Scan", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData27)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData9.AppendField("Op", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData12)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData28 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.List()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData28.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData5)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData9.AppendField("BatchIds", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData28)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData1.AppendField("Row", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData10)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDataBuilder.Build()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDatav, err := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictDatav
}
func init() {
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData = __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData_gen()
}

var __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo *vdl.Type

func __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo_gen() *vdl.Type {
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder := vdl.TypeBuilder{}

	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo1 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo2 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Named("v.io/v23/services/syncbase/nosql.ConflictInfo").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo1)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo3 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Union()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo4 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Named("v.io/v23/services/syncbase/nosql.ConflictData").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo3)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo5 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo6 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Named("v.io/v23/services/syncbase/nosql.BatchInfo").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo5)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo7 := vdl.Uint64Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo5.AppendField("Id", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo7)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo8 := vdl.StringType
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo5.AppendField("Hint", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo9 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Enum()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo10 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Named("v.io/v23/services/syncbase/nosql.BatchSource").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo9)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo9.AppendLabel("Local")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo9.AppendLabel("Remote")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo5.AppendField("Source", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo10)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo3.AppendField("Batch", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo11 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo12 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Named("v.io/v23/services/syncbase/nosql.RowInfo").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo11)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo13 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Union()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo14 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Named("v.io/v23/services/syncbase/nosql.Operation").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo13)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo15 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo16 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Named("v.io/v23/services/syncbase/nosql.RowOp").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo15)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo15.AppendField("Key", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo17 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Optional()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo18 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo19 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo18)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo20 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Enum()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo21 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo20)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo20.AppendLabel("Exists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo20.AppendLabel("NoExists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo20.AppendLabel("Deleted")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo20.AppendLabel("Unknown")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo18.AppendField("State", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo21)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo22 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.List()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo23 := vdl.ByteType
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo22.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo23)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo18.AppendField("Bytes", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo22)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo24 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo25 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Named("time.Time").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo24)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo26 := vdl.Int64Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo24.AppendField("Seconds", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo26)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo27 := vdl.Int32Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo24.AppendField("Nanos", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo27)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo18.AppendField("WriteTs", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo25)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo17.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo19)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo15.AppendField("LocalValue", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo17)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo15.AppendField("RemoteValue", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo17)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo15.AppendField("AncestorValue", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo17)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo13.AppendField("Read", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo16)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo13.AppendField("Write", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo16)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo28 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo29 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Named("v.io/v23/services/syncbase/nosql.ScanOp").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo28)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo28.AppendField("Start", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo28.AppendField("Limit", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo13.AppendField("Scan", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo29)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo11.AppendField("Op", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo14)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo30 := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.List()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo30.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo7)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo11.AppendField("BatchIds", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo30)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo3.AppendField("Row", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo12)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo1.AppendField("Data", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo4)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo31 := vdl.BoolType
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo1.AppendField("Continued", __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo31)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfoBuilder.Build()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfov, err := __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfov
}
func init() {
	__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo = __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo_gen()
}

var __VDLType_types_v_io_v23_services_syncbase_nosql_CrPolicy *vdl.Type = vdl.TypeOf(CrPolicy{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_CrRule *vdl.Type = vdl.TypeOf(CrRule{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_KeyValue *vdl.Type = vdl.TypeOf(KeyValue{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_Operation *vdl.Type

func __VDLType_types_v_io_v23_services_syncbase_nosql_Operation_gen() *vdl.Type {
	__VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder := vdl.TypeBuilder{}

	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation1 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Union()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation2 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Named("v.io/v23/services/syncbase/nosql.Operation").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_Operation1)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation3 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation4 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Named("v.io/v23/services/syncbase/nosql.RowOp").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_Operation3)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation5 := vdl.StringType
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation3.AppendField("Key", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation5)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation6 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Optional()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation7 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation8 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_Operation7)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation9 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Enum()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation10 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_Operation9)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation9.AppendLabel("Exists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation9.AppendLabel("NoExists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation9.AppendLabel("Deleted")
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation9.AppendLabel("Unknown")
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation7.AppendField("State", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation10)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation11 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.List()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation12 := vdl.ByteType
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation11.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_Operation12)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation7.AppendField("Bytes", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation11)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation13 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation14 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Named("time.Time").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_Operation13)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation15 := vdl.Int64Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation13.AppendField("Seconds", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation15)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation16 := vdl.Int32Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation13.AppendField("Nanos", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation16)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation7.AppendField("WriteTs", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation14)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation6.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_Operation8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation3.AppendField("LocalValue", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation3.AppendField("RemoteValue", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation3.AppendField("AncestorValue", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation1.AppendField("Read", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation4)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation1.AppendField("Write", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation4)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation17 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation18 := __VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Named("v.io/v23/services/syncbase/nosql.ScanOp").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_Operation17)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation17.AppendField("Start", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation5)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation17.AppendField("Limit", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation5)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation1.AppendField("Scan", __VDLType_types_v_io_v23_services_syncbase_nosql_Operation18)
	__VDLType_types_v_io_v23_services_syncbase_nosql_OperationBuilder.Build()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operationv, err := __VDLType_types_v_io_v23_services_syncbase_nosql_Operation2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_types_v_io_v23_services_syncbase_nosql_Operationv
}
func init() {
	__VDLType_types_v_io_v23_services_syncbase_nosql_Operation = __VDLType_types_v_io_v23_services_syncbase_nosql_Operation_gen()
}

var __VDLType_types_v_io_v23_services_syncbase_nosql_PrefixPermissions *vdl.Type = vdl.TypeOf(PrefixPermissions{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo *vdl.Type

func __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo_gen() *vdl.Type {
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder := vdl.TypeBuilder{}

	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo1 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo2 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Named("v.io/v23/services/syncbase/nosql.ResolutionInfo").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo1)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo3 := vdl.StringType
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo1.AppendField("Key", __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo3)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo4 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Enum()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo5 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Named("v.io/v23/services/syncbase/nosql.ValueSelection").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo4)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo4.AppendLabel("Local")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo4.AppendLabel("Remote")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo4.AppendLabel("Other")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo1.AppendField("Selection", __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo5)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo6 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Optional()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo7 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo8 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo7)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo9 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Enum()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo10 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo9)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo9.AppendLabel("Exists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo9.AppendLabel("NoExists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo9.AppendLabel("Deleted")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo9.AppendLabel("Unknown")
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo7.AppendField("State", __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo10)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo11 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.List()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo12 := vdl.ByteType
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo11.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo12)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo7.AppendField("Bytes", __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo11)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo13 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo14 := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Named("time.Time").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo13)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo15 := vdl.Int64Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo13.AppendField("Seconds", __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo15)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo16 := vdl.Int32Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo13.AppendField("Nanos", __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo16)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo7.AppendField("WriteTs", __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo14)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo6.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo1.AppendField("Result", __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo17 := vdl.BoolType
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo1.AppendField("Continued", __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo17)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfoBuilder.Build()
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfov, err := __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfov
}
func init() {
	__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo = __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo_gen()
}

var __VDLType_types_v_io_v23_services_syncbase_nosql_ResolverType *vdl.Type = vdl.TypeOf(ResolverTypeLastWins)
var __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo *vdl.Type

func __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo_gen() *vdl.Type {
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder := vdl.TypeBuilder{}

	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo1 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo2 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Named("v.io/v23/services/syncbase/nosql.RowInfo").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo1)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo3 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Union()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo4 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Named("v.io/v23/services/syncbase/nosql.Operation").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo3)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo5 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo6 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Named("v.io/v23/services/syncbase/nosql.RowOp").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo5)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo7 := vdl.StringType
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo5.AppendField("Key", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo7)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo8 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Optional()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo9 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo10 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo9)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo11 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Enum()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo12 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo11)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo11.AppendLabel("Exists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo11.AppendLabel("NoExists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo11.AppendLabel("Deleted")
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo11.AppendLabel("Unknown")
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo9.AppendField("State", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo12)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo13 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.List()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo14 := vdl.ByteType
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo13.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo14)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo9.AppendField("Bytes", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo13)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo15 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo16 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Named("time.Time").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo15)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo17 := vdl.Int64Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo15.AppendField("Seconds", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo17)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo18 := vdl.Int32Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo15.AppendField("Nanos", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo18)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo9.AppendField("WriteTs", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo16)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo8.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo10)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo5.AppendField("LocalValue", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo5.AppendField("RemoteValue", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo5.AppendField("AncestorValue", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo3.AppendField("Read", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo3.AppendField("Write", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo19 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo20 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Named("v.io/v23/services/syncbase/nosql.ScanOp").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo19)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo19.AppendField("Start", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo7)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo19.AppendField("Limit", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo7)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo3.AppendField("Scan", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo20)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo1.AppendField("Op", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo4)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo21 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.List()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo22 := vdl.Uint64Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo21.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo22)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo1.AppendField("BatchIds", __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo21)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfoBuilder.Build()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfov, err := __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfov
}
func init() {
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo = __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo_gen()
}

var __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp *vdl.Type

func __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp_gen() *vdl.Type {
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder := vdl.TypeBuilder{}

	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp1 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp2 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder.Named("v.io/v23/services/syncbase/nosql.RowOp").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp1)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp3 := vdl.StringType
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp1.AppendField("Key", __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp3)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp4 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder.Optional()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp5 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp6 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp5)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp7 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder.Enum()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp8 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp7)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp7.AppendLabel("Exists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp7.AppendLabel("NoExists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp7.AppendLabel("Deleted")
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp7.AppendLabel("Unknown")
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp5.AppendField("State", __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp9 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder.List()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp10 := vdl.ByteType
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp9.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp10)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp5.AppendField("Bytes", __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp9)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp11 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp12 := __VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder.Named("time.Time").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp11)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp13 := vdl.Int64Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp11.AppendField("Seconds", __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp13)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp14 := vdl.Int32Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp11.AppendField("Nanos", __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp14)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp5.AppendField("WriteTs", __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp12)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp4.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp1.AppendField("LocalValue", __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp4)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp1.AppendField("RemoteValue", __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp4)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp1.AppendField("AncestorValue", __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp4)
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOpBuilder.Build()
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOpv, err := __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_types_v_io_v23_services_syncbase_nosql_RowOpv
}
func init() {
	__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp = __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp_gen()
}

var __VDLType_types_v_io_v23_services_syncbase_nosql_ScanOp *vdl.Type = vdl.TypeOf(ScanOp{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_SchemaMetadata *vdl.Type = vdl.TypeOf(SchemaMetadata{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_StoreChange *vdl.Type = vdl.TypeOf(StoreChange{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_SyncgroupMemberInfo *vdl.Type = vdl.TypeOf(SyncgroupMemberInfo{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_SyncgroupSpec *vdl.Type = vdl.TypeOf(SyncgroupSpec{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_TableRow *vdl.Type = vdl.TypeOf(TableRow{})
var __VDLType_types_v_io_v23_services_syncbase_nosql_Value *vdl.Type

func __VDLType_types_v_io_v23_services_syncbase_nosql_Value_gen() *vdl.Type {
	__VDLType_types_v_io_v23_services_syncbase_nosql_ValueBuilder := vdl.TypeBuilder{}

	__VDLType_types_v_io_v23_services_syncbase_nosql_Value1 := __VDLType_types_v_io_v23_services_syncbase_nosql_ValueBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value2 := __VDLType_types_v_io_v23_services_syncbase_nosql_ValueBuilder.Named("v.io/v23/services/syncbase/nosql.Value").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_Value1)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value3 := __VDLType_types_v_io_v23_services_syncbase_nosql_ValueBuilder.Enum()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value4 := __VDLType_types_v_io_v23_services_syncbase_nosql_ValueBuilder.Named("v.io/v23/services/syncbase/nosql.ValueState").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_Value3)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value3.AppendLabel("Exists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value3.AppendLabel("NoExists")
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value3.AppendLabel("Deleted")
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value3.AppendLabel("Unknown")
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value1.AppendField("State", __VDLType_types_v_io_v23_services_syncbase_nosql_Value4)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value5 := __VDLType_types_v_io_v23_services_syncbase_nosql_ValueBuilder.List()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value6 := vdl.ByteType
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value5.AssignElem(__VDLType_types_v_io_v23_services_syncbase_nosql_Value6)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value1.AppendField("Bytes", __VDLType_types_v_io_v23_services_syncbase_nosql_Value5)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value7 := __VDLType_types_v_io_v23_services_syncbase_nosql_ValueBuilder.Struct()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value8 := __VDLType_types_v_io_v23_services_syncbase_nosql_ValueBuilder.Named("time.Time").AssignBase(__VDLType_types_v_io_v23_services_syncbase_nosql_Value7)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value9 := vdl.Int64Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value7.AppendField("Seconds", __VDLType_types_v_io_v23_services_syncbase_nosql_Value9)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value10 := vdl.Int32Type
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value7.AppendField("Nanos", __VDLType_types_v_io_v23_services_syncbase_nosql_Value10)
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value1.AppendField("WriteTs", __VDLType_types_v_io_v23_services_syncbase_nosql_Value8)
	__VDLType_types_v_io_v23_services_syncbase_nosql_ValueBuilder.Build()
	__VDLType_types_v_io_v23_services_syncbase_nosql_Valuev, err := __VDLType_types_v_io_v23_services_syncbase_nosql_Value2.Built()
	if err != nil {
		panic(err)
	}
	return __VDLType_types_v_io_v23_services_syncbase_nosql_Valuev
}
func init() {
	__VDLType_types_v_io_v23_services_syncbase_nosql_Value = __VDLType_types_v_io_v23_services_syncbase_nosql_Value_gen()
}

var __VDLType_types_v_io_v23_services_syncbase_nosql_ValueSelection *vdl.Type = vdl.TypeOf(ValueSelectionLocal)
var __VDLType_types_v_io_v23_services_syncbase_nosql_ValueState *vdl.Type = vdl.TypeOf(ValueStateExists)

func __VDLEnsureNativeBuilt_types() {
	if __VDLTypetypes9 == nil {
		__VDLTypetypes9 = __VDLTypetypes9_gen()
	}
	if __VDLTypetypes16 == nil {
		__VDLTypetypes16 = __VDLTypetypes16_gen()
	}
	if __VDLTypetypes11 == nil {
		__VDLTypetypes11 = __VDLTypetypes11_gen()
	}
	if __VDLTypetypes13 == nil {
		__VDLTypetypes13 = __VDLTypetypes13_gen()
	}
	if __VDLTypetypes14 == nil {
		__VDLTypetypes14 = __VDLTypetypes14_gen()
	}
	if __VDLType_types_time_Time == nil {
		__VDLType_types_time_Time = __VDLType_types_time_Time_gen()
	}
	if __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData == nil {
		__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData = __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictData_gen()
	}
	if __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo == nil {
		__VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo = __VDLType_types_v_io_v23_services_syncbase_nosql_ConflictInfo_gen()
	}
	if __VDLType_types_v_io_v23_services_syncbase_nosql_Operation == nil {
		__VDLType_types_v_io_v23_services_syncbase_nosql_Operation = __VDLType_types_v_io_v23_services_syncbase_nosql_Operation_gen()
	}
	if __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo == nil {
		__VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo = __VDLType_types_v_io_v23_services_syncbase_nosql_ResolutionInfo_gen()
	}
	if __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo == nil {
		__VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo = __VDLType_types_v_io_v23_services_syncbase_nosql_RowInfo_gen()
	}
	if __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp == nil {
		__VDLType_types_v_io_v23_services_syncbase_nosql_RowOp = __VDLType_types_v_io_v23_services_syncbase_nosql_RowOp_gen()
	}
	if __VDLType_types_v_io_v23_services_syncbase_nosql_Value == nil {
		__VDLType_types_v_io_v23_services_syncbase_nosql_Value = __VDLType_types_v_io_v23_services_syncbase_nosql_Value_gen()
	}
}

const NullBlobRef = BlobRef("")