func (box *TSDateNanoBox) Insert(object *TSDateNano) (uint64, error) {
	return box.Box.Insert(object)
}
Insert synchronously inserts a single object. As opposed to Put, Insert will fail if given an ID that already exists.
In case the Id is not specified, it would be assigned automatically (auto-increment).
When inserting, the TSDateNano.Id property on the passed object will be assigned the new ID as well.
package model
import (
	"errors"
	"github.com/google/flatbuffers/go"
	"github.com/objectbox/objectbox-go/objectbox"
	"github.com/objectbox/objectbox-go/objectbox/fbutils"
)
type tSDate_EntityInfo struct {
	objectbox.Entity
	Uid uint64
}
var TSDateBinding = tSDate_EntityInfo{
	Entity: objectbox.Entity{
		Id: 6,
	},
	Uid: 2767047163049667536,
}
var TSDate_ = struct {
	Id   *objectbox.PropertyUint64
	Time *objectbox.PropertyInt64
}{
	Id: &objectbox.PropertyUint64{
		BaseProperty: &objectbox.BaseProperty{
			Id:     1,
			Entity: &TSDateBinding.Entity,
		},
	},
	Time: &objectbox.PropertyInt64{
		BaseProperty: &objectbox.BaseProperty{
			Id:     2,
			Entity: &TSDateBinding.Entity,
		},
	},
}
func (tSDate_EntityInfo) GeneratorVersion() int {
	return 6
}
func (tSDate_EntityInfo) AddToModel(model *objectbox.Model) {
	model.Entity("TSDate", 6, 2767047163049667536)
	model.Property("Id", 6, 1, 1462677146136716215)
	model.PropertyFlags(1)
	model.Property("Time", 10, 2, 180851766275559029)
	model.PropertyFlags(16384)
	model.EntityLastPropertyId(2, 180851766275559029)
}
func (tSDate_EntityInfo) GetId(object interface{}) (uint64, error) {
	return object.(*TSDate).Id, nil
}
func (tSDate_EntityInfo) SetId(object interface{}, id uint64) error {
	object.(*TSDate).Id = id
	return nil
}
func (tSDate_EntityInfo) PutRelated(ob *objectbox.ObjectBox, object interface{}, id uint64) error {
	return nil
}
func (tSDate_EntityInfo) Flatten(object interface{}, fbb *flatbuffers.Builder, id uint64) error {
	obj := object.(*TSDate)
	var propTime int64
	{
		var err error
		propTime, err = objectbox.TimeInt64ConvertToDatabaseValue(obj.Time)
		if err != nil {
			return errors.New("converter objectbox.TimeInt64ConvertToDatabaseValue() failed on TSDate.Time: " + err.Error())
		}
	}
	fbb.StartObject(2)
	fbutils.SetUint64Slot(fbb, 0, id)
	fbutils.SetInt64Slot(fbb, 1, propTime)
	return nil
}
func (tSDate_EntityInfo) Load(ob *objectbox.ObjectBox, bytes []byte) (interface{}, error) {
	if len(bytes) == 0 {  
		return nil, errors.New("can't deserialize an object of type 'TSDate' - no data received")
	}
	var table = &flatbuffers.Table{
		Bytes: bytes,
		Pos:   flatbuffers.GetUOffsetT(bytes),
	}
	var propId = table.GetUint64Slot(4, 0)
	propTime, err := objectbox.TimeInt64ConvertToEntityProperty(fbutils.GetInt64Slot(table, 6))
	if err != nil {
		return nil, errors.New("converter objectbox.TimeInt64ConvertToEntityProperty() failed on TSDate.Time: " + err.Error())
	}
	return &TSDate{
		Id:   propId,
		Time: propTime,
	}, nil
}
func (tSDate_EntityInfo) MakeSlice(capacity int) interface{} {
	return make([]*TSDate, 0, capacity)
}
func (tSDate_EntityInfo) AppendToSlice(slice interface{}, object interface{}) interface{} {
	if object == nil {
		return append(slice.([]*TSDate), nil)
	}
	return append(slice.([]*TSDate), object.(*TSDate))
}
type TSDateBox struct {
	*objectbox.Box
}
func BoxForTSDate(ob *objectbox.ObjectBox) *TSDateBox {
	return &TSDateBox{
		Box: ob.InternalBox(6),
	}
}
func (box *TSDateBox) Put(object *TSDate) (uint64, error) {
	return box.Box.Put(object)
}
func (box *TSDateBox) Insert(object *TSDate) (uint64, error) {
	return box.Box.Insert(object)
}
func (box *TSDateBox) Update(object *TSDate) error {
	return box.Box.Update(object)
}
func (box *TSDateBox) PutAsync(object *TSDate) (uint64, error) {
	return box.Box.PutAsync(object)
}
func (box *TSDateBox) PutMany(objects []*TSDate) ([]uint64, error) {
	return box.Box.PutMany(objects)
}
func (box *TSDateBox) Get(id uint64) (*TSDate, error) {
	object, err := box.Box.Get(id)
	if err != nil {
		return nil, err
	} else if object == nil {
		return nil, nil
	}
	return object.(*TSDate), nil
}
func (box *TSDateBox) GetMany(ids ...uint64) ([]*TSDate, error) {
	objects, err := box.Box.GetMany(ids...)
	if err != nil {
		return nil, err
	}
	return objects.([]*TSDate), nil
}
func (box *TSDateBox) GetManyExisting(ids ...uint64) ([]*TSDate, error) {
	objects, err := box.Box.GetManyExisting(ids...)
	if err != nil {
		return nil, err
	}
	return objects.([]*TSDate), nil
}
func (box *TSDateBox) GetAll() ([]*TSDate, error) {
	objects, err := box.Box.GetAll()
	if err != nil {
		return nil, err
	}
	return objects.([]*TSDate), nil
}
func (box *TSDateBox) Remove(object *TSDate) error {
	return box.Box.Remove(object)
}
func (box *TSDateBox) RemoveMany(objects ...*TSDate) (uint64, error) {
	var ids = make([]uint64, len(objects))
	for k, object := range objects {
		ids[k] = object.Id
	}
	return box.Box.RemoveIds(ids...)
}
func (box *TSDateBox) Query(conditions ...objectbox.Condition) *TSDateQuery {
	return &TSDateQuery{
		box.Box.Query(conditions...),
	}
}
func (box *TSDateBox) QueryOrError(conditions ...objectbox.Condition) (*TSDateQuery, error) {
	if query, err := box.Box.QueryOrError(conditions...); err != nil {
		return nil, err
	} else {
		return &TSDateQuery{query}, nil
	}
}
func (box *TSDateBox) Async() *TSDateAsyncBox {
	return &TSDateAsyncBox{AsyncBox: box.Box.Async()}
}
type TSDateAsyncBox struct {
	*objectbox.AsyncBox
}
func AsyncBoxForTSDate(ob *objectbox.ObjectBox, timeoutMs uint64) *TSDateAsyncBox {
	var async, err = objectbox.NewAsyncBox(ob, 6, timeoutMs)
	if err != nil {
		panic("Could not create async box for entity ID 6: %s" + err.Error())
	}
	return &TSDateAsyncBox{AsyncBox: async}
}
func (asyncBox *TSDateAsyncBox) Put(object *TSDate) (uint64, error) {
	return asyncBox.AsyncBox.Put(object)
}
func (asyncBox *TSDateAsyncBox) Insert(object *TSDate) (id uint64, err error) {
	return asyncBox.AsyncBox.Insert(object)
}
func (asyncBox *TSDateAsyncBox) Update(object *TSDate) error {
	return asyncBox.AsyncBox.Update(object)
}
func (asyncBox *TSDateAsyncBox) Remove(object *TSDate) error {
	return asyncBox.AsyncBox.Remove(object)
}
type TSDateQuery struct {
	*objectbox.Query
}
func (query *TSDateQuery) Find() ([]*TSDate, error) {
	objects, err := query.Query.Find()
	if err != nil {
		return nil, err
	}
	return objects.([]*TSDate), nil
}
func (query *TSDateQuery) Offset(offset uint64) *TSDateQuery {
	query.Query.Offset(offset)
	return query
}
func (query *TSDateQuery) Limit(limit uint64) *TSDateQuery {
	query.Query.Limit(limit)
	return query
}
type tSDateNano_EntityInfo struct {
	objectbox.Entity
	Uid uint64
}
var TSDateNanoBinding = tSDateNano_EntityInfo{
	Entity: objectbox.Entity{
		Id: 7,
	},
	Uid: 8200223062288330287,
}
var TSDateNano_ = struct {
	Id   *objectbox.PropertyUint64
	Time *objectbox.PropertyInt64
}{
	Id: &objectbox.PropertyUint64{
		BaseProperty: &objectbox.BaseProperty{
			Id:     1,
			Entity: &TSDateNanoBinding.Entity,
		},
	},
	Time: &objectbox.PropertyInt64{
		BaseProperty: &objectbox.BaseProperty{
			Id:     2,
			Entity: &TSDateNanoBinding.Entity,
		},
	},
}
func (tSDateNano_EntityInfo) GeneratorVersion() int {
	return 6
}
func (tSDateNano_EntityInfo) AddToModel(model *objectbox.Model) {
	model.Entity("TSDateNano", 7, 8200223062288330287)
	model.Property("Id", 6, 1, 7438841713427308701)
	model.PropertyFlags(1)
	model.Property("Time", 12, 2, 6159670697406080312)
	model.PropertyFlags(16384)
	model.EntityLastPropertyId(2, 6159670697406080312)
}
func (tSDateNano_EntityInfo) GetId(object interface{}) (uint64, error) {
	return object.(*TSDateNano).Id, nil
}
func (tSDateNano_EntityInfo) SetId(object interface{}, id uint64) error {
	object.(*TSDateNano).Id = id
	return nil
}
func (tSDateNano_EntityInfo) PutRelated(ob *objectbox.ObjectBox, object interface{}, id uint64) error {
	return nil
}
func (tSDateNano_EntityInfo) Flatten(object interface{}, fbb *flatbuffers.Builder, id uint64) error {
	obj := object.(*TSDateNano)
	var propTime int64
	{
		var err error
		propTime, err = objectbox.NanoTimeInt64ConvertToDatabaseValue(obj.Time)
		if err != nil {
			return errors.New("converter objectbox.NanoTimeInt64ConvertToDatabaseValue() failed on TSDateNano.Time: " + err.Error())
		}
	}
	fbb.StartObject(2)
	fbutils.SetUint64Slot(fbb, 0, id)
	fbutils.SetInt64Slot(fbb, 1, propTime)
	return nil
}
func (tSDateNano_EntityInfo) Load(ob *objectbox.ObjectBox, bytes []byte) (interface{}, error) {
	if len(bytes) == 0 {  
		return nil, errors.New("can't deserialize an object of type 'TSDateNano' - no data received")
	}
	var table = &flatbuffers.Table{
		Bytes: bytes,
		Pos:   flatbuffers.GetUOffsetT(bytes),
	}
	var propId = table.GetUint64Slot(4, 0)
	propTime, err := objectbox.NanoTimeInt64ConvertToEntityProperty(fbutils.GetInt64Slot(table, 6))
	if err != nil {
		return nil, errors.New("converter objectbox.NanoTimeInt64ConvertToEntityProperty() failed on TSDateNano.Time: " + err.Error())
	}
	return &TSDateNano{
		Id:   propId,
		Time: propTime,
	}, nil
}
func (tSDateNano_EntityInfo) MakeSlice(capacity int) interface{} {
	return make([]*TSDateNano, 0, capacity)
}
func (tSDateNano_EntityInfo) AppendToSlice(slice interface{}, object interface{}) interface{} {
	if object == nil {
		return append(slice.([]*TSDateNano), nil)
	}
	return append(slice.([]*TSDateNano), object.(*TSDateNano))
}
type TSDateNanoBox struct {
	*objectbox.Box
}
func BoxForTSDateNano(ob *objectbox.ObjectBox) *TSDateNanoBox {
	return &TSDateNanoBox{
		Box: ob.InternalBox(7),
	}
}
func (box *TSDateNanoBox) Put(object *TSDateNano) (uint64, error) {
	return box.Box.Put(object)
}