#ifndef OBJECTBOX_H

#define OBJECTBOX_H

#include <stdbool.h>

#include <stdint.h>

#include <stdio.h>

#ifdef __cplusplus

extern "C" {

#ifndef OBX_C_API

#define OBX_C_API

#define OBX_VERSION_MAJOR 5

#define OBX_VERSION_MINOR 3

#define OBX_VERSION_PATCH 2 // values >= 100 are reserved for dev releases leading to the next minor/major increase

typedef uint32_t obx_schema_id;

typedef uint64_t obx_uid;

typedef uint64_t obx_id;

typedef struct OBX_id_score {

} OBX_id_score;

typedef int obx_err;

typedef bool obx_data_visitor(const void* data, size_t size, void* user_data);

struct OBX_bytes_score; // Forward declaration for the obx_data_score_visitor typedef

typedef bool obx_data_score_visitor(const struct OBX_bytes_score* data, void* user_data);

OBX_C_API void obx_version(int* major, int* minor, int* patch);

OBX_C_API bool obx_version_is_at_least(int major, int minor, int patch);

OBX_C_API const char* obx_version_string(void);

OBX_C_API const char* obx_version_date_string(void);

OBX_C_API const char* obx_version_core_string(void);

typedef enum {

/// Functions that are returning multiple results (e.g. multiple objects) can be only used if this is available.

/// This is only available for 64-bit OSes and is the opposite of "chunked mode", which forces to consume results

/// in chunks (e.g. one by one).

/// Since chunked mode consumes a bit less RAM, ResultArray style functions are typically only preferable if

/// there's an additional overhead per call, e.g. caused by a higher level language abstraction like CGo.

OBXFeature_ResultArray = 1,

/// TimeSeries support (date/date-nano companion ID and other time-series functionality).

OBXFeature_TimeSeries = 2,

/// Sync client availability. Visit https://objectbox.io/sync for more details.

OBXFeature_Sync = 3,

/// Check whether debug log can be enabled during runtime.

OBXFeature_DebugLog = 4,

/// Admin UI including a database browser, user management, and more.

/// Depends on HttpServer (if Admin is available HttpServer is too).

OBXFeature_Admin = 5,

/// Tree with special GraphQL support

OBXFeature_Tree = 6,

/// Sync server availability. Visit https://objectbox.io/sync for more details.

OBXFeature_SyncServer = 7,

/// Implicitly added by Sync or SyncServer; disable via NoWebSockets

OBXFeature_WebSockets = 8,

/// Sync Server has cluster functionality.

/// Implicitly added by SyncServer; disable via NoCluster

OBXFeature_Cluster = 9,

/// Embedded HTTP server.

OBXFeature_HttpServer = 10,

/// Embedded GraphQL server (via HTTP).

/// Depends on HttpServer (if GraphQL is available HttpServer is too).

OBXFeature_GraphQL = 11,

/// Database Backup functionality; typically only enabled in Sync Server builds.

OBXFeature_Backup = 12,

/// The default database "provider"; writes data persistently to disk (ACID).

OBXFeature_Lmdb = 13,

/// Vector search functionality; enables indexing for nearest neighbor search.

OBXFeature_VectorSearch = 14,

/// WAL (write-ahead logging).

OBXFeature_Wal = 15,

/// Sync connector to integrate MongoDB with SyncServer.

OBXFeature_SyncMongoDb = 16,

/// Enables additional authentication/authorization methods for sync login, e.g. JWT based methods.

OBXFeature_Auth = 17,

/// This is a free trial version; only applies to server builds (no trial builds for database and Sync clients).

OBXFeature_Trial = 18,

/// Server-side filters to return individual data for each sync user (user-specific data).

OBXFeature_SyncFilters = 19,

} OBXFeature;

OBX_C_API bool obx_has_feature(OBXFeature feature);

typedef enum {

OBXLogLevel_All = 0, ///< Enable all log output.

OBXLogLevel_Trace = 1, ///< Most detailed; typically only for short-term investigations.

OBXLogLevel_Verbose = 2, ///< Very detailed; not printed by default.

OBXLogLevel_Debug = 3, ///< Detailed output useful during development/debugging.

OBXLogLevel_Info = 4, ///< Informational messages (default for release builds).

OBXLogLevel_Warn = 6, ///< Noteworthy issues that are not necessarily errors.

OBXLogLevel_Error = 8, ///< Only for "bad things happened" (e.g. internal errors).

OBXLogLevel_None = 10, ///< Disable all log output.

} OBXLogLevel;

typedef void obx_log_callback(OBXLogLevel log_level, const char* message, size_t message_size, void* user_data);

#define OBX_ID_NEW 0xFFFFFFFFFFFFFFFF

OBX_C_API obx_err obx_remove_db_files(char const* directory);

OBX_C_API size_t obx_db_file_size(char const* directory);

OBX_C_API obx_err obx_debug_log(bool enabled);

OBX_C_API bool obx_debug_log_enabled();

OBX_C_API obx_err obx_log_level_set(OBXLogLevel log_level);

OBX_C_API OBXLogLevel obx_log_level_get();

OBX_C_API int obx_thread_number();

#define OBX_SUCCESS 0

#define OBX_NOT_FOUND 404

#define OBX_NO_SUCCESS 1001

#define OBX_TIMEOUT 1002

#define OBX_ERROR_ILLEGAL_STATE 10001

#define OBX_ERROR_ILLEGAL_ARGUMENT 10002

#define OBX_ERROR_ALLOCATION 10003

#define OBX_ERROR_NUMERIC_OVERFLOW 10004

#define OBX_ERROR_FEATURE_NOT_AVAILABLE 10005

#define OBX_ERROR_SHUTTING_DOWN 10006

#define OBX_ERROR_IO 10007

#define OBX_ERROR_BACKUP_FILE_INVALID 10008

#define OBX_ERROR_NO_ERROR_INFO 10097

#define OBX_ERROR_GENERAL 10098

#define OBX_ERROR_UNKNOWN 10099

#define OBX_ERROR_DB_FULL 10101

#define OBX_ERROR_MAX_READERS_EXCEEDED 10102

#define OBX_ERROR_STORE_MUST_SHUTDOWN 10103

#define OBX_ERROR_MAX_DATA_SIZE_EXCEEDED 10104

#define OBX_ERROR_DB_GENERAL 10198

#define OBX_ERROR_STORAGE_GENERAL 10199

#define OBX_ERROR_UNIQUE_VIOLATED 10201

#define OBX_ERROR_NON_UNIQUE_RESULT 10202

#define OBX_ERROR_PROPERTY_TYPE_MISMATCH 10203

#define OBX_ERROR_ID_ALREADY_EXISTS 10210

#define OBX_ERROR_ID_NOT_FOUND 10211

#define OBX_ERROR_TIME_SERIES 10212

#define OBX_ERROR_CONSTRAINT_VIOLATED 10299

#define OBX_ERROR_STD_ILLEGAL_ARGUMENT 10301

#define OBX_ERROR_STD_OUT_OF_RANGE 10302

#define OBX_ERROR_STD_LENGTH 10303

#define OBX_ERROR_STD_BAD_ALLOC 10304

#define OBX_ERROR_STD_RANGE 10305

#define OBX_ERROR_STD_OVERFLOW 10306

#define OBX_ERROR_STD_OTHER 10399

#define OBX_ERROR_SCHEMA 10501

#define OBX_ERROR_FILE_CORRUPT 10502

#define OBX_ERROR_FILE_PAGES_CORRUPT 10503

#define OBX_ERROR_SCHEMA_OBJECT_NOT_FOUND 10504

#define OBX_ERROR_TREE_MODEL_INVALID 10601

#define OBX_ERROR_TREE_VALUE_TYPE_MISMATCH 10602

#define OBX_ERROR_TREE_PATH_NON_UNIQUE 10603

#define OBX_ERROR_TREE_PATH_ILLEGAL 10604

#define OBX_ERROR_TREE_OTHER 10699

OBX_C_API bool obx_last_error_pop(obx_err* out_error, const char** out_message);

OBX_C_API obx_err obx_last_error_code(void);

OBX_C_API const char* obx_last_error_message(void);

OBX_C_API obx_err obx_last_error_secondary(void);

OBX_C_API void obx_last_error_clear(void);

OBX_C_API bool obx_last_error_set(obx_err code, obx_err secondary, const char* message);

typedef enum {

OBXPropertyType_Unknown = 0, ///< Not a actual type; represents an uninitialized or invalid type

OBXPropertyType_Bool = 1, ///< A boolean (flag)

OBXPropertyType_Byte = 2, ///< 8-bit integer

OBXPropertyType_Short = 3, ///< 16-bit integer

OBXPropertyType_Char = 4, ///< 16-bit character

OBXPropertyType_Int = 5, ///< 32-bit integer

OBXPropertyType_Long = 6, ///< 64-bit integer

OBXPropertyType_Float = 7, ///< 32-bit floating point number

OBXPropertyType_Double = 8, ///< 64-bit floating point number

OBXPropertyType_String = 9, ///< UTF-8 encoded string (variable length)

OBXPropertyType_Date = 10, ///< 64-bit (integer) timestamp; milliseconds since 1970-01-01 (unix epoch)

OBXPropertyType_Relation = 11, ///< Relation to another entity

OBXPropertyType_DateNano = 12, ///< High precision 64-bit timestamp; nanoseconds since 1970-01-01 (unix epoch)

OBXPropertyType_Flex = 13, ///< Flexible" type, which may contain scalars (integers, floating points), strings or

///< containers (lists and maps). Note: a flex map must use string keys.

OBXPropertyType_BoolVector = 22, ///< Variable sized vector of Bool values (note: each value is one byte)

OBXPropertyType_ByteVector = 23, ///< Variable sized vector of Byte values (8-bit integers)

OBXPropertyType_ShortVector = 24, ///< Variable sized vector of Short values (16-bit integers)

OBXPropertyType_CharVector = 25, ///< Variable sized vector of Char values (16-bit characters)

OBXPropertyType_IntVector = 26, ///< Variable sized vector of Int values (32-bit integers)

OBXPropertyType_LongVector = 27, ///< Variable sized vector of Long values (64-bit integers)

OBXPropertyType_FloatVector = 28, ///< Variable sized vector of Float values (32-bit floating point numbers)

OBXPropertyType_DoubleVector = 29, ///< Variable sized vector of Double values (64-bit floating point numbers)

OBXPropertyType_StringVector = 30, ///< Variable sized vector of String values (UTF-8 encoded strings).

OBXPropertyType_DateVector = 31, ///< Variable sized vector of Date values (64-bit timestamp).

OBXPropertyType_DateNanoVector = 32, ///< Variable sized vector of Date values (high precision 64-bit timestamp).

} OBXPropertyType;

typedef enum {

/// Not a real type, just best practice (e.g. forward compatibility)

OBXVectorDistanceType_Unknown = 0,

/// The default; typically "Euclidean squared" internally.

OBXVectorDistanceType_Euclidean = 1,

/// Cosine similarity compares two vectors irrespective of their magnitude (compares the angle of two vectors).

/// Often used for document or semantic similarity.

/// Value range: 0.0 - 2.0 (0.0: same direction, 1.0: orthogonal, 2.0: opposite direction)

OBXVectorDistanceType_Cosine = 2,

/// For normalized vectors (vector length == 1.0), the dot product is equivalent to the cosine similarity.

/// Because of this, the dot product is often preferred as it performs better.

/// Value range (normalized vectors): 0.0 - 2.0 (0.0: same direction, 1.0: orthogonal, 2.0: opposite direction)

OBXVectorDistanceType_DotProduct = 3,

// OBXVectorDistanceType_Manhattan = 4,

// OBXVectorDistanceType_Hamming = 5,

/// For geospatial coordinates aka latitude/longitude pairs.

/// Note, that the vector dimension must be 2, with the latitude being the first element and longitude the second.

/// Internally, this uses haversine distance.

OBXVectorDistanceType_Geo = 6,

/// A custom dot product similarity measure that does not require the vectors to be normalized.

/// Note: this is no replacement for cosine similarity (like DotProduct for normalized vectors is).

/// The non-linear conversion provides a high precision over the entire float range (for the raw dot product).

/// The higher the dot product, the lower the distance is (the nearer the vectors are).

/// The more negative the dot product, the higher the distance is (the farther the vectors are).

/// Value range: 0.0 - 2.0 (nonlinear; 0.0: nearest, 1.0: orthogonal, 2.0: farthest)

OBXVectorDistanceType_DotProductNonNormalized = 10,

} OBXVectorDistanceType;

OBX_C_API float obx_vector_distance_float32(OBXVectorDistanceType type, const float* vector1, const float* vector2,

size_t dimension);

OBX_C_API float obx_vector_distance_to_relevance(OBXVectorDistanceType type, float distance);

typedef enum {

OBXHnswFlags_None = 0,

/// Enables debug logs.

OBXHnswFlags_DebugLogs = 1,

/// Enables "high volume" debug logs, e.g. individual gets/puts.

OBXHnswFlags_DebugLogsDetailed = 2,

/// Padding for SIMD is enabled by default, which uses more memory but may be faster. This flag turns it off.

OBXHnswFlags_VectorCacheSimdPaddingOff = 4,

/// If the speed of removing nodes becomes a concern in your use case, you can speed it up by setting this flag.

/// By default, repairing the graph after node removals creates more connections to improve the graph's quality.

/// The extra costs for this are relatively low (e.g. vs. regular indexing), and thus the default is recommended.

OBXHnswFlags_ReparationLimitCandidates = 8,

} OBXHnswFlags;

typedef enum {

/// Enable "data synchronization" for this entity type: objects will be synced with other stores over the network.

/// It's possible to have local-only (non-synced) types and synced types in the same store (schema/data model).

OBXEntityFlags_SYNC_ENABLED = 2,

/// Makes object IDs for a synced types (SYNC_ENABLED is set) global.

/// By default (not using this flag), the 64 bit object IDs have a local scope and are not unique globally.

/// This flag tells ObjectBox to treat object IDs globally and thus no ID mapping (local <-> global) is performed.

/// Often this is used with assignable IDs (ID_SELF_ASSIGNABLE property flag is set) and some special ID scheme.

/// Note: typically you won't do this with automatically assigned IDs, set by the local ObjectBox store.

/// Two devices would likely overwrite each other's object during sync as object IDs are prone to collide.

/// It might be OK if you can somehow ensure that only a single device will create new IDs.

OBXEntityFlags_SHARED_GLOBAL_IDS = 4,

} OBXEntityFlags;

typedef enum {

/// 64 bit long property (internally unsigned) representing the ID of the entity.

/// May be combined with: NON_PRIMITIVE_TYPE, ID_MONOTONIC_SEQUENCE, ID_SELF_ASSIGNABLE.

OBXPropertyFlags_ID = 1,

/// On languages like Java, a non-primitive type is used (aka wrapper types, allowing null)

OBXPropertyFlags_NON_PRIMITIVE_TYPE = 2,

/// Unused yet

OBXPropertyFlags_NOT_NULL = 4,

OBXPropertyFlags_INDEXED = 8,

/// Unused yet

OBXPropertyFlags_RESERVED = 16,

/// Unique index

OBXPropertyFlags_UNIQUE = 32,

/// Unused yet: Use a persisted sequence to enforce ID to rise monotonic (no ID reuse)

OBXPropertyFlags_ID_MONOTONIC_SEQUENCE = 64,

/// Allow IDs to be assigned by the developer

OBXPropertyFlags_ID_SELF_ASSIGNABLE = 128,

/// Unused yet

OBXPropertyFlags_INDEX_PARTIAL_SKIP_NULL = 256,

/// Used by References for 1) back-references and 2) to clear references to deleted objects (required for ID reuse)

OBXPropertyFlags_INDEX_PARTIAL_SKIP_ZERO = 512,

/// Virtual properties may not have a dedicated field in their entity class, e.g. target IDs of to-one relations

OBXPropertyFlags_VIRTUAL = 1024,

/// Index uses a 32 bit hash instead of the value

/// 32 bits is shorter on disk, runs well on 32 bit systems, and should be OK even with a few collisions

OBXPropertyFlags_INDEX_HASH = 2048,

/// Index uses a 64 bit hash instead of the value

/// recommended mostly for 64 bit machines with values longer >200 bytes; small values are faster with a 32 bit hash

OBXPropertyFlags_INDEX_HASH64 = 4096,

/// The actual type of the variable is unsigned (used in combination with numeric OBXPropertyType_*).

/// While our default are signed ints, queries & indexes need do know signing info.

/// Note: Don't combine with ID (IDs are always unsigned internally).

OBXPropertyFlags_UNSIGNED = 8192,

/// By defining an ID companion property, a special ID encoding scheme is activated involving this property.

///

/// For Time Series IDs, a companion property of type Date or DateNano represents the exact timestamp.

OBXPropertyFlags_ID_COMPANION = 16384,

/// Unique on-conflict strategy: the object being put replaces any existing conflicting object (deletes it).

OBXPropertyFlags_UNIQUE_ON_CONFLICT_REPLACE = 32768,

/// If a date property has this flag (max. one per entity type), the date value specifies the time by which

/// the object expires, at which point it MAY be removed (deleted), which can be triggered by an API call.

OBXPropertyFlags_EXPIRATION_TIME = 65536,

/// Marks a Long (64-bit integer) property as the sync clock, a "hybrid logical clock" to resolve Sync conflicts.

/// These clock values allow "last write wins" conflict resolution.

/// There can be only one sync clock per sync entity type; which is also recommended for basic conflict resolution.

/// For new objects, initialize a property value to 0 to reserve "a slot" in the object data.

/// ObjectBox Sync will update this property automatically on put operations.

/// As a hybrid clock, it combines a wall clock with a logical counter to compensate for some clock skew effects.

OBXPropertyFlags_SYNC_CLOCK = 131072,

/// Marks a Long (64-bit integer) property as the "sync precedence" to customize Sync conflict resolution.

/// Developer-assigned precedence values are then used to resolve conflicts via "higher precedence wins".

/// Defining and assigning precedence values are completely in the hands of the developer (the ObjectBox user).

/// There can be only one sync precedence per sync entity type.

/// Typically, it is combined with a sync clock, with the latter being the tie-breaker for equal precedence values.

OBXPropertyFlags_SYNC_PRECEDENCE = 262144,

} OBXPropertyFlags;

typedef enum {

/// Not a real type: represents uninitialized state and can be used for forward compatibility.

OBXExternalPropertyType_Unknown = 0,

/// Representing type: ByteVector

/// Encoding: 1:1 binary representation, little endian (16 bytes)

OBXExternalPropertyType_Int128 = 100,

// OBXExternalPropertyType_Reserved1 = 101,

/// A UUID (Universally Unique Identifier) as defined by RFC 9562.

/// ObjectBox uses the UUIDv7 scheme (timestamp + random) to create new UUIDs.

/// UUIDv7 is a good choice for database keys as it's mostly sequential and encodes a timestamp.

/// However, if keys are used externally, consider UuidV4 for better privacy by not exposing any time information.

/// Representing type: ByteVector

/// Encoding: 1:1 binary representation (16 bytes)

OBXExternalPropertyType_Uuid = 102,

/// IEEE 754 decimal128 type, e.g. supported by MongoDB

/// Representing type: ByteVector

/// Encoding: 1:1 binary representation (16 bytes)

OBXExternalPropertyType_Decimal128 = 103,

/// UUID represented as a string of 36 characters, e.g. "019571b4-80e3-7516-a5c1-5f1053d23fff".

/// For efficient storage, consider the Uuid type instead, which occupies only 16 bytes (20 bytes less).

/// This type may still be a convenient alternative as the string type is widely supported and more human-readable.

/// In accordance to standards, new UUIDs generated by ObjectBox use lowercase hexadecimal digits.

/// Representing type: String

OBXExternalPropertyType_UuidString = 104,

/// A UUID (Universally Unique Identifier) as defined by RFC 9562.

/// ObjectBox uses the UUIDv4 scheme (completely random) to create new UUIDs.

/// Representing type: ByteVector

/// Encoding: 1:1 binary representation (16 bytes)

OBXExternalPropertyType_UuidV4 = 105,

/// Like UuidString, but using the UUIDv4 scheme (completely random) to create new UUID.

/// Representing type: String

OBXExternalPropertyType_UuidV4String = 106,

/// A key/value map; e.g. corresponds to a JSON object or a MongoDB document (although not keeping the key order).

/// Unlike the Flex type, this must contain a map value (e.g. not a vector or a scalar).

/// Representing type: Flex

/// Encoding: Flex

OBXExternalPropertyType_FlexMap = 107,

/// A vector (aka list or array) of flexible elements; e.g. corresponds to a JSON array or a MongoDB array.

/// Unlike the Flex type, this must contain a vector value (e.g. not a map or a scalar).

/// Representing type: Flex

/// Encoding: Flex

OBXExternalPropertyType_FlexVector = 108,

/// Placeholder (not yet used) for a JSON document.

/// Representing type: String

OBXExternalPropertyType_Json = 109,

/// Placeholder (not yet used) for a BSON document.

/// Representing type: ByteVector

OBXExternalPropertyType_Bson = 110,

/// JavaScript source code

/// Representing type: String

OBXExternalPropertyType_JavaScript = 111,

/// A JSON string that is converted to a native representation in the external system.

/// For example, a JSON object on the ObjectBox side (string) would be converted to an embedded document in MongoDB.

/// It depends on the external system what kind of JSON structures is supported.

/// For MongoDB, this is very flexible and allows (nested) objects, arrays, primitives, etc.

/// Representing type: String

OBXExternalPropertyType_JsonToNative = 112,

// OBXExternalPropertyType_Reserved6 = 113,

// OBXExternalPropertyType_Reserved7 = 114,

// OBXExternalPropertyType_Reserved8 = 115,

/// A vector (array) of Int128 values

OBXExternalPropertyType_Int128Vector = 116,

// OBXExternalPropertyType_Reserved9 = 117,

/// A vector (array) of Uuid values

OBXExternalPropertyType_UuidVector = 118,

// OBXExternalPropertyType_Reserved10 = 119,

// OBXExternalPropertyType_Reserved11 = 120,

// OBXExternalPropertyType_Reserved12 = 121,

// OBXExternalPropertyType_Reserved13 = 122,

/// The 12-byte ObjectId type in MongoDB

/// Representing type: ByteVector

/// Encoding: 1:1 binary representation (12 bytes)

OBXExternalPropertyType_MongoId = 123,

/// A vector (array) of MongoId values

OBXExternalPropertyType_MongoIdVector = 124,

/// Representing type: Long

/// Encoding: Two unsigned 32-bit integers merged into a 64-bit integer.

OBXExternalPropertyType_MongoTimestamp = 125,

/// Representing type: ByteVector

/// Encoding: 3 zero bytes (reserved, functions as padding), fourth byte is the sub-type,

/// followed by the binary data.

OBXExternalPropertyType_MongoBinary = 126,

/// Representing type: string vector with 2 elements (index 0: pattern, index 1: options)

/// Encoding: 1:1 string representation

OBXExternalPropertyType_MongoRegex = 127,

} OBXExternalPropertyType;

struct OBX_model; // doxygen (only) picks up the typedef struct below

typedef struct OBX_model OBX_model;

OBX_C_API OBX_model* obx_model(void);

OBX_C_API obx_err obx_model_free(OBX_model* model);

OBX_C_API obx_err obx_model_error_code(OBX_model* model);

OBX_C_API const char* obx_model_error_message(OBX_model* model);

OBX_C_API obx_err obx_model_entity(OBX_model* model, const char* name, obx_schema_id entity_id, obx_uid entity_uid);

OBX_C_API obx_err obx_model_entity_flags(OBX_model* model, uint32_t flags);

OBX_C_API obx_err obx_model_entity_last_property_id(OBX_model* model, obx_schema_id property_id, obx_uid property_uid);

OBX_C_API obx_err obx_model_entity_external_name(OBX_model* model, const char* external_name);

OBX_C_API obx_err obx_model_property(OBX_model* model, const char* name, OBXPropertyType type,

obx_schema_id property_id, obx_uid property_uid);

OBX_C_API obx_err obx_model_property_flags(OBX_model* model, uint32_t flags);

OBX_C_API obx_err obx_model_property_relation(OBX_model* model, const char* target_entity, obx_schema_id index_id,

obx_uid index_uid);

OBX_C_API obx_err obx_model_property_index_id(OBX_model* model, obx_schema_id index_id, obx_uid index_uid);

OBX_C_API obx_err obx_model_property_external_name(OBX_model* model, const char* external_name);

OBX_C_API obx_err obx_model_property_external_type(OBX_model* model, OBXExternalPropertyType external_type);

OBX_C_API obx_err obx_model_property_index_hnsw_dimensions(OBX_model* model, size_t value);

OBX_C_API obx_err obx_model_property_index_hnsw_neighbors_per_node(OBX_model* model, uint32_t value);

OBX_C_API obx_err obx_model_property_index_hnsw_indexing_search_count(OBX_model* model, uint32_t value);

OBX_C_API obx_err obx_model_property_index_hnsw_flags(OBX_model* model, uint32_t flags);

OBX_C_API obx_err obx_model_property_index_hnsw_distance_type(OBX_model* model, OBXVectorDistanceType value);

OBX_C_API obx_err obx_model_property_index_hnsw_reparation_backlink_probability(OBX_model* model, float value);

OBX_C_API obx_err obx_model_property_index_hnsw_vector_cache_hint_size_kb(OBX_model* model, size_t value);

OBX_C_API obx_err obx_model_relation(OBX_model* model, obx_schema_id relation_id, obx_uid relation_uid,

obx_schema_id target_id, obx_uid target_uid);

OBX_C_API obx_err obx_model_relation_name(OBX_model* model, const char* name);

OBX_C_API obx_err obx_model_relation_external_name(OBX_model* model, const char* external_name);

OBX_C_API obx_err obx_model_relation_external_type(OBX_model* model, OBXExternalPropertyType external_type);

OBX_C_API void obx_model_last_entity_id(OBX_model*, obx_schema_id entity_id, obx_uid entity_uid);

OBX_C_API void obx_model_last_index_id(OBX_model* model, obx_schema_id index_id, obx_uid index_uid);

OBX_C_API void obx_model_last_relation_id(OBX_model* model, obx_schema_id relation_id, obx_uid relation_uid);

struct OBX_store; // doxygen (only) picks up the typedef struct below

typedef struct OBX_store OBX_store;

struct OBX_store_options; // doxygen (only) picks up the typedef struct below

typedef struct OBX_store_options OBX_store_options;

typedef enum {

OBXDebugFlags_LOG_TRANSACTIONS_READ = 1,

OBXDebugFlags_LOG_TRANSACTIONS_WRITE = 2,

OBXDebugFlags_LOG_QUERIES = 4,

OBXDebugFlags_LOG_QUERY_PARAMETERS = 8,

OBXDebugFlags_LOG_ASYNC_QUEUE = 16,

OBXDebugFlags_LOG_CACHE_HITS = 32,

OBXDebugFlags_LOG_CACHE_ALL = 64,

OBXDebugFlags_LOG_TREE = 128,

/// For a limited number of error conditions, this will try to print stack traces.

/// Note: this is Linux-only, experimental, and has several limitations:

/// The usefulness of these stack traces depends on several factors and might not be helpful at all.

OBXDebugFlags_LOG_EXCEPTION_STACK_TRACE = 256,

/// Run a quick self-test to verify basic threading; somewhat paranoia to check the platform and the library setup.

OBXDebugFlags_RUN_THREADING_SELF_TEST = 512,

} OBXDebugFlags;

typedef enum {

OBXValidateOnOpenPagesFlags_None = 0, ///< No special flags

/// Enable validation of leaf pages (by default only branch pages are validated)

OBXValidateOnOpenPagesFlags_VisitLeafPages = 1,

} OBXValidateOnOpenPagesFlags;

typedef enum {

OBXValidateOnOpenKvFlags_None = 0, ///< No special flags

} OBXValidateOnOpenKvFlags;

typedef enum {

/// Adds a padding when needed (may require a memory copy): this is the safe option and also the default.

/// The extra memory copy may impact performance, however this is usually not noticeable.

OBXPutPaddingMode_PaddingAutomatic = 1,

/// Indicates that data buffers are safe to be extended for padding (adding up to 3 bytes to size is OK).

/// Typically, it depends on the used FlatBuffers builder; e.g. the official C++ seems to ensure it, but

/// flatcc (3rd party implementation for plain C) may not.

OBXPutPaddingMode_PaddingAllowedByBuffer = 2,

/// The caller ensures that all data bytes are already padded.

/// ObjectBox will verify the buffer size and returns an error if it's not divisible by 4.

OBXPutPaddingMode_PaddingByCaller = 3,

} OBXPutPaddingMode;

typedef enum {

/// Do not include a timestamp in the backup file (time when the backup file is generated).

OBXBackupFlags_ExcludeTimestamp = 0x1,

/// Do not include a random salt in the backup file.

OBXBackupFlags_ExcludeSalt = 0x2,

} OBXBackupFlags;

typedef enum {

/// Enable Wal

OBXWalFlags_EnableWal = 0x1,

/// Does not wait for the disk to acknowledge; faster but not ACID compliant (not generally recommended).

OBXWalFlags_NoSyncFile = 0x2,

} OBXWalFlags;

typedef struct OBX_bytes {

const void* data;

size_t size;

} OBX_bytes;

typedef struct OBX_bytes_array {

OBX_bytes* bytes;

size_t count;

} OBX_bytes_array;