func AsyncBoxForEntity(ob *objectbox.ObjectBox, timeoutMs uint64) *EntityAsyncBox {
	var async, err = objectbox.NewAsyncBox(ob, 1, timeoutMs)
	if err != nil {
		panic("Could not create async box for entity ID 1: %s" + err.Error())
	}
	return &EntityAsyncBox{AsyncBox: async}
}
AsyncBoxForEntity creates a new async box with the given operation timeout in case an async queue is full.
The returned struct must be freed explicitly using the Close() method.
It's usually preferable to use EntityBox::Async() which takes care of resource management and doesn't require closing.
package perf
import (
	"errors"
	"github.com/google/flatbuffers/go"
	"github.com/objectbox/objectbox-go/objectbox"
	"github.com/objectbox/objectbox-go/objectbox/fbutils"
)
type entity_EntityInfo struct {
	objectbox.Entity
	Uid uint64
}
var EntityBinding = entity_EntityInfo{
	Entity: objectbox.Entity{
		Id: 1,
	},
	Uid: 1737161401460991620,
}
var Entity_ = struct {
	ID      *objectbox.PropertyUint64
	Int32   *objectbox.PropertyInt32
	Int64   *objectbox.PropertyInt64
	String  *objectbox.PropertyString
	Float64 *objectbox.PropertyFloat64
}{
	ID: &objectbox.PropertyUint64{
		BaseProperty: &objectbox.BaseProperty{
			Id:     1,
			Entity: &EntityBinding.Entity,
		},
	},
	Int32: &objectbox.PropertyInt32{
		BaseProperty: &objectbox.BaseProperty{
			Id:     2,
			Entity: &EntityBinding.Entity,
		},
	},
	Int64: &objectbox.PropertyInt64{
		BaseProperty: &objectbox.BaseProperty{
			Id:     3,
			Entity: &EntityBinding.Entity,
		},
	},
	String: &objectbox.PropertyString{
		BaseProperty: &objectbox.BaseProperty{
			Id:     4,
			Entity: &EntityBinding.Entity,
		},
	},
	Float64: &objectbox.PropertyFloat64{
		BaseProperty: &objectbox.BaseProperty{
			Id:     5,
			Entity: &EntityBinding.Entity,
		},
	},
}
func (entity_EntityInfo) GeneratorVersion() int {
	return 6
}
func (entity_EntityInfo) AddToModel(model *objectbox.Model) {
	model.Entity("Entity", 1, 1737161401460991620)
	model.Property("ID", 6, 1, 7373286741377356014)
	model.PropertyFlags(1)
	model.Property("Int32", 5, 2, 4837914178321008766)
	model.Property("Int64", 6, 3, 3841825182616422591)
	model.Property("String", 9, 4, 6473251296493454829)
	model.Property("Float64", 8, 5, 8933082277725371577)
	model.EntityLastPropertyId(5, 8933082277725371577)
}
func (entity_EntityInfo) GetId(object interface{}) (uint64, error) {
	return object.(*Entity).ID, nil
}
func (entity_EntityInfo) SetId(object interface{}, id uint64) error {
	object.(*Entity).ID = id
	return nil
}
func (entity_EntityInfo) PutRelated(ob *objectbox.ObjectBox, object interface{}, id uint64) error {
	return nil
}
func (entity_EntityInfo) Flatten(object interface{}, fbb *flatbuffers.Builder, id uint64) error {
	obj := object.(*Entity)
	var offsetString = fbutils.CreateStringOffset(fbb, obj.String)
	fbb.StartObject(5)
	fbutils.SetUint64Slot(fbb, 0, id)
	fbutils.SetInt32Slot(fbb, 1, obj.Int32)
	fbutils.SetInt64Slot(fbb, 2, obj.Int64)
	fbutils.SetUOffsetTSlot(fbb, 3, offsetString)
	fbutils.SetFloat64Slot(fbb, 4, obj.Float64)
	return nil
}
func (entity_EntityInfo) Load(ob *objectbox.ObjectBox, bytes []byte) (interface{}, error) {
	if len(bytes) == 0 {  
		return nil, errors.New("can't deserialize an object of type 'Entity' - no data received")
	}
	var table = &flatbuffers.Table{
		Bytes: bytes,
		Pos:   flatbuffers.GetUOffsetT(bytes),
	}
	var propID = table.GetUint64Slot(4, 0)
	return &Entity{
		ID:      propID,
		Int32:   fbutils.GetInt32Slot(table, 6),
		Int64:   fbutils.GetInt64Slot(table, 8),
		String:  fbutils.GetStringSlot(table, 10),
		Float64: fbutils.GetFloat64Slot(table, 12),
	}, nil
}
func (entity_EntityInfo) MakeSlice(capacity int) interface{} {
	return make([]*Entity, 0, capacity)
}
func (entity_EntityInfo) AppendToSlice(slice interface{}, object interface{}) interface{} {
	if object == nil {
		return append(slice.([]*Entity), nil)
	}
	return append(slice.([]*Entity), object.(*Entity))
}
type EntityBox struct {
	*objectbox.Box
}
func BoxForEntity(ob *objectbox.ObjectBox) *EntityBox {
	return &EntityBox{
		Box: ob.InternalBox(1),
	}
}
func (box *EntityBox) Put(object *Entity) (uint64, error) {
	return box.Box.Put(object)
}
func (box *EntityBox) Insert(object *Entity) (uint64, error) {
	return box.Box.Insert(object)
}
func (box *EntityBox) Update(object *Entity) error {
	return box.Box.Update(object)
}
func (box *EntityBox) PutAsync(object *Entity) (uint64, error) {
	return box.Box.PutAsync(object)
}
func (box *EntityBox) PutMany(objects []*Entity) ([]uint64, error) {
	return box.Box.PutMany(objects)
}
func (box *EntityBox) Get(id uint64) (*Entity, error) {
	object, err := box.Box.Get(id)
	if err != nil {
		return nil, err
	} else if object == nil {
		return nil, nil
	}
	return object.(*Entity), nil
}
func (box *EntityBox) GetMany(ids ...uint64) ([]*Entity, error) {
	objects, err := box.Box.GetMany(ids...)
	if err != nil {
		return nil, err
	}
	return objects.([]*Entity), nil
}
func (box *EntityBox) GetManyExisting(ids ...uint64) ([]*Entity, error) {
	objects, err := box.Box.GetManyExisting(ids...)
	if err != nil {
		return nil, err
	}
	return objects.([]*Entity), nil
}
func (box *EntityBox) GetAll() ([]*Entity, error) {
	objects, err := box.Box.GetAll()
	if err != nil {
		return nil, err
	}
	return objects.([]*Entity), nil
}
func (box *EntityBox) Remove(object *Entity) error {
	return box.Box.Remove(object)
}
func (box *EntityBox) RemoveMany(objects ...*Entity) (uint64, error) {
	var ids = make([]uint64, len(objects))
	for k, object := range objects {
		ids[k] = object.ID
	}
	return box.Box.RemoveIds(ids...)
}
func (box *EntityBox) Query(conditions ...objectbox.Condition) *EntityQuery {
	return &EntityQuery{
		box.Box.Query(conditions...),
	}
}
func (box *EntityBox) QueryOrError(conditions ...objectbox.Condition) (*EntityQuery, error) {
	if query, err := box.Box.QueryOrError(conditions...); err != nil {
		return nil, err
	} else {
		return &EntityQuery{query}, nil
	}
}
func (box *EntityBox) Async() *EntityAsyncBox {
	return &EntityAsyncBox{AsyncBox: box.Box.Async()}
}
type EntityAsyncBox struct {
	*objectbox.AsyncBox
}