func (box *EntityBox) PutMany(objects []*Entity) ([]uint64, error) {
	return box.Box.PutMany(objects)
}
PutMany inserts multiple objects in single transaction.
In case IDs are not set on the objects, they would be assigned automatically (auto-increment).

Returns: IDs of the put objects (in the same order).
When inserting, the Entity.ID property on the objects in the slice will be assigned the new IDs as well.

Note: In case an error occurs during the transaction, some of the objects may already have the Entity.ID assigned
even though the transaction has been rolled back and the objects are not stored under those IDs.

Note: The slice may be empty or even nil; in both cases, an empty IDs slice and no error is returned.
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)
}