func (asyncBox *TSDateNanoAsyncBox) Put(object *TSDateNano) (uint64, error) {
	return asyncBox.AsyncBox.Put(object)
}
Put inserts/updates a single object asynchronously.
When inserting a new object, the Id property on the passed object will be assigned the new ID the entity would hold
if the insert is ultimately successful. The newly assigned ID may not become valid if the insert fails.
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)
}
func (box *TSDateNanoBox) Insert(object *TSDateNano) (uint64, error) {
	return box.Box.Insert(object)
}
func (box *TSDateNanoBox) Update(object *TSDateNano) error {
	return box.Box.Update(object)
}
func (box *TSDateNanoBox) PutAsync(object *TSDateNano) (uint64, error) {
	return box.Box.PutAsync(object)
}
func (box *TSDateNanoBox) PutMany(objects []*TSDateNano) ([]uint64, error) {
	return box.Box.PutMany(objects)
}
func (box *TSDateNanoBox) Get(id uint64) (*TSDateNano, error) {
	object, err := box.Box.Get(id)
	if err != nil {
		return nil, err
	} else if object == nil {
		return nil, nil
	}
	return object.(*TSDateNano), nil
}
func (box *TSDateNanoBox) GetMany(ids ...uint64) ([]*TSDateNano, error) {
	objects, err := box.Box.GetMany(ids...)
	if err != nil {
		return nil, err
	}
	return objects.([]*TSDateNano), nil
}
func (box *TSDateNanoBox) GetManyExisting(ids ...uint64) ([]*TSDateNano, error) {
	objects, err := box.Box.GetManyExisting(ids...)
	if err != nil {
		return nil, err
	}
	return objects.([]*TSDateNano), nil
}
func (box *TSDateNanoBox) GetAll() ([]*TSDateNano, error) {
	objects, err := box.Box.GetAll()
	if err != nil {
		return nil, err
	}
	return objects.([]*TSDateNano), nil
}
func (box *TSDateNanoBox) Remove(object *TSDateNano) error {
	return box.Box.Remove(object)
}
func (box *TSDateNanoBox) RemoveMany(objects ...*TSDateNano) (uint64, error) {
	var ids = make([]uint64, len(objects))
	for k, object := range objects {
		ids[k] = object.Id
	}
	return box.Box.RemoveIds(ids...)
}
func (box *TSDateNanoBox) Query(conditions ...objectbox.Condition) *TSDateNanoQuery {
	return &TSDateNanoQuery{
		box.Box.Query(conditions...),
	}
}
func (box *TSDateNanoBox) QueryOrError(conditions ...objectbox.Condition) (*TSDateNanoQuery, error) {
	if query, err := box.Box.QueryOrError(conditions...); err != nil {
		return nil, err
	} else {
		return &TSDateNanoQuery{query}, nil
	}
}
func (box *TSDateNanoBox) Async() *TSDateNanoAsyncBox {
	return &TSDateNanoAsyncBox{AsyncBox: box.Box.Async()}
}
type TSDateNanoAsyncBox struct {
	*objectbox.AsyncBox
}
func AsyncBoxForTSDateNano(ob *objectbox.ObjectBox, timeoutMs uint64) *TSDateNanoAsyncBox {
	var async, err = objectbox.NewAsyncBox(ob, 7, timeoutMs)
	if err != nil {
		panic("Could not create async box for entity ID 7: %s" + err.Error())
	}
	return &TSDateNanoAsyncBox{AsyncBox: async}
}