Skip to main content

zvec_rust_sys/
lib.rs

1//! Raw FFI bindings to the zvec C-API.
2//!
3//! This crate provides low-level Rust bindings to the zvec vector database C library.
4//! It exposes opaque pointer types, constants, and function declarations that mirror
5//! the C API exactly. For a safer, more idiomatic Rust interface, consider using the
6//! higher-level `zvec` crate which wraps these raw bindings.
7//!
8//! # Safety
9//!
10//! All functions in this crate are `unsafe` by nature as they interact with C code.
11//! Proper memory management and lifetime handling is the responsibility of the caller.
12
13#![allow(non_camel_case_types, non_upper_case_globals)]
14
15use std::os::raw::{c_char, c_int, c_void};
16
17// =============================================================================
18// Opaque Pointer Types
19// =============================================================================
20
21/// Opaque pointer to a vector collection instance.
22/// Represents an opened collection that can be used for read/write operations.
23#[repr(C)]
24pub struct zvec_collection_t {
25    _private: [u8; 0],
26}
27
28/// Opaque pointer to a collection schema definition.
29/// Defines the structure of fields and indexes in a collection.
30#[repr(C)]
31pub struct zvec_collection_schema_t {
32    _private: [u8; 0],
33}
34
35/// Opaque pointer to a field schema definition.
36/// Defines the properties of a single field including type, index, etc.
37#[repr(C)]
38pub struct zvec_field_schema_t {
39    _private: [u8; 0],
40}
41
42/// Opaque pointer to index configuration parameters.
43/// Contains settings for HNSW, IVF, or other index types.
44#[repr(C)]
45pub struct zvec_index_params_t {
46    _private: [u8; 0],
47}
48
49/// Opaque pointer to a document instance.
50/// Represents a single record with fields and values in a collection.
51#[repr(C)]
52pub struct zvec_doc_t {
53    _private: [u8; 0],
54}
55
56/// Opaque pointer to a vector query object.
57/// Configures search parameters for vector similarity queries.
58#[repr(C)]
59pub struct zvec_vector_query_t {
60    _private: [u8; 0],
61}
62
63/// Opaque pointer to a group-by vector query object.
64/// Configures grouped vector search with aggregation parameters.
65#[repr(C)]
66pub struct zvec_group_by_vector_query_t {
67    _private: [u8; 0],
68}
69
70/// Opaque pointer to collection opening options.
71/// Controls behavior like MMAP, buffer size, and read-only mode.
72#[repr(C)]
73pub struct zvec_collection_options_t {
74    _private: [u8; 0],
75}
76
77/// Opaque pointer to collection statistics data.
78/// Contains metrics like document count and index completeness.
79#[repr(C)]
80pub struct zvec_collection_stats_t {
81    _private: [u8; 0],
82}
83
84/// Opaque pointer to global configuration data.
85/// Manages memory limits, thread counts, and other system-wide settings.
86#[repr(C)]
87pub struct zvec_config_data_t {
88    _private: [u8; 0],
89}
90
91/// Opaque pointer to logging configuration.
92/// Controls log level, output type (console/file), and file rotation settings.
93#[repr(C)]
94pub struct zvec_log_config_t {
95    _private: [u8; 0],
96}
97
98/// Opaque pointer to HNSW index query parameters.
99/// Configures ef, radius, and refiner settings for HNSW searches.
100#[repr(C)]
101pub struct zvec_hnsw_query_params_t {
102    _private: [u8; 0],
103}
104
105/// Opaque pointer to IVF index query parameters.
106/// Configures nprobe, scale factor, and refiner settings for IVF searches.
107#[repr(C)]
108pub struct zvec_ivf_query_params_t {
109    _private: [u8; 0],
110}
111
112/// Opaque pointer to IVF RaBitQ index query parameters.
113/// Configures nprobe, scale factor, and refiner settings for IVF RaBitQ searches.
114#[repr(C)]
115pub struct zvec_ivf_rabitq_query_params_t {
116    _private: [u8; 0],
117}
118
119/// Opaque pointer to flat index query parameters.
120/// Configures scale factor and refiner settings for brute-force searches.
121#[repr(C)]
122pub struct zvec_flat_query_params_t {
123    _private: [u8; 0],
124}
125
126/// Opaque pointer to Vamana index query parameters.
127/// Configures ef_search, radius, and refiner settings for Vamana searches.
128#[repr(C)]
129pub struct zvec_vamana_query_params_t {
130    _private: [u8; 0],
131}
132
133/// Opaque pointer to DiskANN index query parameters.
134/// Configures list_size, radius, and refiner settings for DiskANN searches.
135#[repr(C)]
136pub struct zvec_diskann_query_params_t {
137    _private: [u8; 0],
138}
139
140/// Opaque pointer to FTS query parameters.
141/// Controls the default boolean operator for adjacent bare terms.
142#[repr(C)]
143pub struct zvec_fts_query_params_t {
144    _private: [u8; 0],
145}
146
147/// Opaque pointer to FTS query payload.
148/// Holds query_string (boolean expression) and match_string (natural-language).
149#[repr(C)]
150pub struct zvec_fts_t {
151    _private: [u8; 0],
152}
153
154/// Opaque pointer to a multi-query object.
155/// Combines multiple sub-queries with a re-ranking strategy (RRF / Weighted).
156#[repr(C)]
157pub struct zvec_multi_query_t {
158    _private: [u8; 0],
159}
160
161/// Opaque pointer to a sub-query object used inside a multi-query.
162/// Carries a per-field vector or sparse vector and index-specific parameters.
163#[repr(C)]
164pub struct zvec_sub_query_t {
165    _private: [u8; 0],
166}
167
168/// Opaque pointer to a document iterator for full collection traversal.
169/// Created by `zvec_collection_create_iterator`, released by `zvec_doc_iterator_close`.
170/// Iterates over an isolated snapshot taken at creation time.
171#[repr(C)]
172pub struct zvec_doc_iterator_t {
173    _private: [u8; 0],
174}
175
176/// Opaque pointer to document iterator options.
177/// Controls which scalar fields and whether vectors are returned.
178#[repr(C)]
179pub struct zvec_iterator_options_t {
180    _private: [u8; 0],
181}
182
183// =============================================================================
184// Type Aliases
185// =============================================================================
186
187/// Error code returned by zvec functions.
188pub type zvec_error_code_t = u32;
189/// Data type identifier for field values.
190pub type zvec_data_type_t = u32;
191/// Index algorithm type identifier.
192pub type zvec_index_type_t = u32;
193/// Distance metric type for vector similarity.
194pub type zvec_metric_type_t = u32;
195/// Quantization type for vector compression.
196pub type zvec_quantize_type_t = u32;
197/// Log severity level.
198pub type zvec_log_level_t = u32;
199/// Log output destination type.
200pub type zvec_log_type_t = u32;
201/// Document operation type (insert/update/delete).
202pub type zvec_doc_operator_t = u32;
203
204// =============================================================================
205// Error Code Constants
206// =============================================================================
207
208/// Operation completed successfully.
209pub const ZVEC_OK: zvec_error_code_t = 0;
210/// Requested resource was not found.
211pub const ZVEC_ERROR_NOT_FOUND: zvec_error_code_t = 1;
212/// Resource already exists.
213pub const ZVEC_ERROR_ALREADY_EXISTS: zvec_error_code_t = 2;
214/// Invalid argument provided.
215pub const ZVEC_ERROR_INVALID_ARGUMENT: zvec_error_code_t = 3;
216/// Permission denied for the operation.
217pub const ZVEC_ERROR_PERMISSION_DENIED: zvec_error_code_t = 4;
218/// Operation failed due to unmet precondition.
219pub const ZVEC_ERROR_FAILED_PRECONDITION: zvec_error_code_t = 5;
220/// System resources exhausted.
221pub const ZVEC_ERROR_RESOURCE_EXHAUSTED: zvec_error_code_t = 6;
222/// Service is currently unavailable.
223pub const ZVEC_ERROR_UNAVAILABLE: zvec_error_code_t = 7;
224/// Internal system error occurred.
225pub const ZVEC_ERROR_INTERNAL_ERROR: zvec_error_code_t = 8;
226/// Operation is not supported.
227pub const ZVEC_ERROR_NOT_SUPPORTED: zvec_error_code_t = 9;
228/// Unknown error occurred.
229pub const ZVEC_ERROR_UNKNOWN: zvec_error_code_t = 10;
230
231// =============================================================================
232// Data Type Constants
233// =============================================================================
234
235/// Undefined data type.
236pub const ZVEC_DATA_TYPE_UNDEFINED: zvec_data_type_t = 0;
237/// Binary data type.
238pub const ZVEC_DATA_TYPE_BINARY: zvec_data_type_t = 1;
239/// String data type.
240pub const ZVEC_DATA_TYPE_STRING: zvec_data_type_t = 2;
241/// Boolean data type.
242pub const ZVEC_DATA_TYPE_BOOL: zvec_data_type_t = 3;
243/// 32-bit signed integer.
244pub const ZVEC_DATA_TYPE_INT32: zvec_data_type_t = 4;
245/// 64-bit signed integer.
246pub const ZVEC_DATA_TYPE_INT64: zvec_data_type_t = 5;
247/// 32-bit unsigned integer.
248pub const ZVEC_DATA_TYPE_UINT32: zvec_data_type_t = 6;
249/// 64-bit unsigned integer.
250pub const ZVEC_DATA_TYPE_UINT64: zvec_data_type_t = 7;
251/// 32-bit floating point.
252pub const ZVEC_DATA_TYPE_FLOAT: zvec_data_type_t = 8;
253/// 64-bit floating point.
254pub const ZVEC_DATA_TYPE_DOUBLE: zvec_data_type_t = 9;
255/// Dense vector with binary32 (float) elements.
256pub const ZVEC_DATA_TYPE_VECTOR_BINARY32: zvec_data_type_t = 20;
257/// Dense vector with binary64 (double) elements.
258pub const ZVEC_DATA_TYPE_VECTOR_BINARY64: zvec_data_type_t = 21;
259/// Dense vector with FP16 (half precision) elements.
260pub const ZVEC_DATA_TYPE_VECTOR_FP16: zvec_data_type_t = 22;
261/// Dense vector with FP32 (single precision) elements.
262pub const ZVEC_DATA_TYPE_VECTOR_FP32: zvec_data_type_t = 23;
263/// Dense vector with FP64 (double precision) elements.
264pub const ZVEC_DATA_TYPE_VECTOR_FP64: zvec_data_type_t = 24;
265/// Dense vector with INT4 quantized elements.
266pub const ZVEC_DATA_TYPE_VECTOR_INT4: zvec_data_type_t = 25;
267/// Dense vector with INT8 quantized elements.
268pub const ZVEC_DATA_TYPE_VECTOR_INT8: zvec_data_type_t = 26;
269/// Dense vector with INT16 quantized elements.
270pub const ZVEC_DATA_TYPE_VECTOR_INT16: zvec_data_type_t = 27;
271/// Sparse vector with FP16 elements.
272pub const ZVEC_DATA_TYPE_SPARSE_VECTOR_FP16: zvec_data_type_t = 30;
273/// Sparse vector with FP32 elements.
274pub const ZVEC_DATA_TYPE_SPARSE_VECTOR_FP32: zvec_data_type_t = 31;
275/// Array of binary values.
276pub const ZVEC_DATA_TYPE_ARRAY_BINARY: zvec_data_type_t = 40;
277/// Array of strings.
278pub const ZVEC_DATA_TYPE_ARRAY_STRING: zvec_data_type_t = 41;
279/// Array of booleans.
280pub const ZVEC_DATA_TYPE_ARRAY_BOOL: zvec_data_type_t = 42;
281/// Array of 32-bit signed integers.
282pub const ZVEC_DATA_TYPE_ARRAY_INT32: zvec_data_type_t = 43;
283/// Array of 64-bit signed integers.
284pub const ZVEC_DATA_TYPE_ARRAY_INT64: zvec_data_type_t = 44;
285/// Array of 32-bit unsigned integers.
286pub const ZVEC_DATA_TYPE_ARRAY_UINT32: zvec_data_type_t = 45;
287/// Array of 64-bit unsigned integers.
288pub const ZVEC_DATA_TYPE_ARRAY_UINT64: zvec_data_type_t = 46;
289/// Array of 32-bit floats.
290pub const ZVEC_DATA_TYPE_ARRAY_FLOAT: zvec_data_type_t = 47;
291/// Array of 64-bit doubles.
292pub const ZVEC_DATA_TYPE_ARRAY_DOUBLE: zvec_data_type_t = 48;
293
294// =============================================================================
295// Index Type Constants
296// =============================================================================
297
298/// Undefined index type.
299pub const ZVEC_INDEX_TYPE_UNDEFINED: zvec_index_type_t = 0;
300/// HNSW (Hierarchical Navigable Small World) graph index.
301pub const ZVEC_INDEX_TYPE_HNSW: zvec_index_type_t = 1;
302/// IVF (Inverted File Index) with clustering.
303pub const ZVEC_INDEX_TYPE_IVF: zvec_index_type_t = 2;
304/// Flat/brute-force index (exact search).
305pub const ZVEC_INDEX_TYPE_FLAT: zvec_index_type_t = 3;
306/// HNSW graph index with RaBitQ quantization.
307pub const ZVEC_INDEX_TYPE_HNSW_RABITQ: zvec_index_type_t = 4;
308/// DiskANN disk-based graph index.
309pub const ZVEC_INDEX_TYPE_DISKANN: zvec_index_type_t = 5;
310/// Vamana disk-based graph index.
311pub const ZVEC_INDEX_TYPE_VAMANA: zvec_index_type_t = 6;
312/// IVF index with RaBitQ quantization.
313pub const ZVEC_INDEX_TYPE_IVF_RABITQ: zvec_index_type_t = 7;
314/// Inverted index for scalar field filtering.
315pub const ZVEC_INDEX_TYPE_INVERT: zvec_index_type_t = 10;
316/// Full-text search index.
317pub const ZVEC_INDEX_TYPE_FTS: zvec_index_type_t = 11;
318
319// =============================================================================
320// Metric Type Constants
321// =============================================================================
322
323/// Undefined metric type.
324pub const ZVEC_METRIC_TYPE_UNDEFINED: zvec_metric_type_t = 0;
325/// L2 (Euclidean) distance.
326pub const ZVEC_METRIC_TYPE_L2: zvec_metric_type_t = 1;
327/// Inner product (dot product).
328pub const ZVEC_METRIC_TYPE_IP: zvec_metric_type_t = 2;
329/// Cosine similarity.
330pub const ZVEC_METRIC_TYPE_COSINE: zvec_metric_type_t = 3;
331/// MIPS converted to L2 distance.
332pub const ZVEC_METRIC_TYPE_MIPSL2: zvec_metric_type_t = 4;
333
334// =============================================================================
335// Quantize Type Constants
336// =============================================================================
337
338/// Undefined quantization type.
339pub const ZVEC_QUANTIZE_TYPE_UNDEFINED: zvec_quantize_type_t = 0;
340/// FP16 (half precision) quantization.
341pub const ZVEC_QUANTIZE_TYPE_FP16: zvec_quantize_type_t = 1;
342/// INT8 (8-bit integer) quantization.
343pub const ZVEC_QUANTIZE_TYPE_INT8: zvec_quantize_type_t = 2;
344/// INT4 (4-bit integer) quantization.
345pub const ZVEC_QUANTIZE_TYPE_INT4: zvec_quantize_type_t = 3;
346/// RaBitQ quantization.
347pub const ZVEC_QUANTIZE_TYPE_RABITQ: zvec_quantize_type_t = 4;
348
349// =============================================================================
350// Log Level Constants
351// =============================================================================
352
353/// Debug level logging (most verbose).
354pub const ZVEC_LOG_LEVEL_DEBUG: zvec_log_level_t = 0;
355/// Info level logging.
356pub const ZVEC_LOG_LEVEL_INFO: zvec_log_level_t = 1;
357/// Warning level logging.
358pub const ZVEC_LOG_LEVEL_WARN: zvec_log_level_t = 2;
359/// Error level logging.
360pub const ZVEC_LOG_LEVEL_ERROR: zvec_log_level_t = 3;
361/// Fatal level logging (least verbose, critical errors only).
362pub const ZVEC_LOG_LEVEL_FATAL: zvec_log_level_t = 4;
363
364// =============================================================================
365// Log Type Constants
366// =============================================================================
367
368/// Console output logging.
369pub const ZVEC_LOG_TYPE_CONSOLE: zvec_log_type_t = 0;
370/// File output logging.
371pub const ZVEC_LOG_TYPE_FILE: zvec_log_type_t = 1;
372
373// =============================================================================
374// Doc Operator Constants
375// =============================================================================
376
377/// Insert operation (fails if document exists).
378pub const ZVEC_DOC_OP_INSERT: zvec_doc_operator_t = 0;
379/// Update operation (fails if document doesn't exist).
380pub const ZVEC_DOC_OP_UPDATE: zvec_doc_operator_t = 1;
381/// Upsert operation (insert or update).
382pub const ZVEC_DOC_OP_UPSERT: zvec_doc_operator_t = 2;
383/// Delete operation.
384pub const ZVEC_DOC_OP_DELETE: zvec_doc_operator_t = 3;
385
386// =============================================================================
387// Non-Opaque Structures
388// =============================================================================
389
390/// A non-owning view of a string (pointer + length).
391#[repr(C)]
392pub struct zvec_string_view_t {
393    pub data: *const c_char,
394    pub length: usize,
395}
396
397/// An owning, mutable string with capacity tracking.
398#[repr(C)]
399pub struct zvec_string_t {
400    pub data: *mut c_char,
401    pub length: usize,
402    pub capacity: usize,
403}
404
405/// An array of owned strings.
406#[repr(C)]
407pub struct zvec_string_array_t {
408    pub strings: *mut zvec_string_t,
409    pub count: usize,
410}
411
412/// A view of a float array (non-owning).
413#[repr(C)]
414pub struct zvec_float_array_t {
415    pub data: *const f32,
416    pub length: usize,
417}
418
419/// A view of an int64 array (non-owning).
420#[repr(C)]
421pub struct zvec_int64_array_t {
422    pub data: *const i64,
423    pub length: usize,
424}
425
426/// A view of a byte array (non-owning).
427#[repr(C)]
428pub struct zvec_byte_array_t {
429    pub data: *const u8,
430    pub length: usize,
431}
432
433/// A mutable, owning byte array with capacity tracking.
434#[repr(C)]
435pub struct zvec_mutable_byte_array_t {
436    pub data: *mut u8,
437    pub length: usize,
438    pub capacity: usize,
439}
440
441/// Result of a write operation (insert/update/delete).
442#[repr(C)]
443pub struct zvec_write_result_t {
444    pub code: zvec_error_code_t,
445    pub message: *const c_char,
446}
447
448/// Detailed error information including source location.
449#[repr(C)]
450pub struct zvec_error_details_t {
451    pub code: zvec_error_code_t,
452    pub message: *const c_char,
453    pub file: *const c_char,
454    pub line: c_int,
455    pub function: *const c_char,
456}
457
458// =============================================================================
459// FFI Function Declarations
460// =============================================================================
461
462extern "C" {
463    // -------------------------------------------------------------------------
464    // Version
465    // Functions for retrieving library version information.
466    // -------------------------------------------------------------------------
467    pub fn zvec_get_version() -> *const c_char;
468    pub fn zvec_check_version(major: c_int, minor: c_int, patch: c_int) -> bool;
469    pub fn zvec_get_version_major() -> c_int;
470    pub fn zvec_get_version_minor() -> c_int;
471    pub fn zvec_get_version_patch() -> c_int;
472
473    // -------------------------------------------------------------------------
474    // Error
475    // Functions for error handling and retrieval.
476    // -------------------------------------------------------------------------
477    pub fn zvec_get_last_error_details(
478        error_details: *mut zvec_error_details_t,
479    ) -> zvec_error_code_t;
480    pub fn zvec_get_last_error(error_msg: *mut *mut c_char) -> zvec_error_code_t;
481    pub fn zvec_clear_error();
482    pub fn zvec_error_code_to_string(error_code: zvec_error_code_t) -> *const c_char;
483
484    // -------------------------------------------------------------------------
485    // String Management
486    // Functions for creating, manipulating, and freeing string objects.
487    // -------------------------------------------------------------------------
488    pub fn zvec_string_create(str: *const c_char) -> *mut zvec_string_t;
489    pub fn zvec_string_create_from_view(view: *const zvec_string_view_t) -> *mut zvec_string_t;
490    pub fn zvec_bin_create(data: *const u8, length: usize) -> *mut zvec_string_t;
491    pub fn zvec_string_copy(str: *const zvec_string_t) -> *mut zvec_string_t;
492    pub fn zvec_string_c_str(str: *const zvec_string_t) -> *const c_char;
493    pub fn zvec_string_length(str: *const zvec_string_t) -> usize;
494    pub fn zvec_string_compare(str1: *const zvec_string_t, str2: *const zvec_string_t) -> c_int;
495    pub fn zvec_free_string(str: *mut zvec_string_t);
496
497    // -------------------------------------------------------------------------
498    // Array Management
499    // Functions for creating and managing arrays of various types.
500    // -------------------------------------------------------------------------
501    pub fn zvec_string_array_create(count: usize) -> *mut zvec_string_array_t;
502    pub fn zvec_string_array_add(array: *mut zvec_string_array_t, idx: usize, str: *const c_char);
503    pub fn zvec_string_array_destroy(array: *mut zvec_string_array_t);
504    pub fn zvec_byte_array_create(capacity: usize) -> *mut zvec_mutable_byte_array_t;
505    pub fn zvec_byte_array_destroy(array: *mut zvec_mutable_byte_array_t);
506    pub fn zvec_float_array_create(count: usize) -> *mut zvec_float_array_t;
507    pub fn zvec_float_array_destroy(array: *mut zvec_float_array_t);
508    pub fn zvec_int64_array_create(count: usize) -> *mut zvec_int64_array_t;
509    pub fn zvec_int64_array_destroy(array: *mut zvec_int64_array_t);
510    pub fn zvec_free_uint8_array(array: *mut u8);
511
512    // -------------------------------------------------------------------------
513    // Memory
514    // Functions for memory allocation and deallocation.
515    // -------------------------------------------------------------------------
516    pub fn zvec_malloc(size: usize) -> *mut c_void;
517    pub fn zvec_free(ptr: *mut c_void);
518
519    // -------------------------------------------------------------------------
520    // Log Configuration
521    // Functions for configuring logging behavior.
522    // -------------------------------------------------------------------------
523    pub fn zvec_config_log_create_console(level: zvec_log_level_t) -> *mut zvec_log_config_t;
524    pub fn zvec_config_log_create_file(
525        level: zvec_log_level_t,
526        dir: *const c_char,
527        basename: *const c_char,
528        file_size: u32,
529        overdue_days: u32,
530    ) -> *mut zvec_log_config_t;
531    pub fn zvec_config_log_destroy(config: *mut zvec_log_config_t);
532    pub fn zvec_config_log_get_level(config: *const zvec_log_config_t) -> zvec_log_level_t;
533    pub fn zvec_config_log_set_level(
534        config: *mut zvec_log_config_t,
535        level: zvec_log_level_t,
536    ) -> zvec_error_code_t;
537    pub fn zvec_config_log_is_file_type(config: *const zvec_log_config_t) -> bool;
538    pub fn zvec_config_log_get_dir(config: *const zvec_log_config_t) -> *const c_char;
539    pub fn zvec_config_log_set_dir(
540        config: *mut zvec_log_config_t,
541        dir: *const c_char,
542    ) -> zvec_error_code_t;
543    pub fn zvec_config_log_get_basename(config: *const zvec_log_config_t) -> *const c_char;
544    pub fn zvec_config_log_set_basename(
545        config: *mut zvec_log_config_t,
546        basename: *const c_char,
547    ) -> zvec_error_code_t;
548    pub fn zvec_config_log_get_file_size(config: *const zvec_log_config_t) -> u32;
549    pub fn zvec_config_log_set_file_size(
550        config: *mut zvec_log_config_t,
551        file_size: u32,
552    ) -> zvec_error_code_t;
553    pub fn zvec_config_log_get_overdue_days(config: *const zvec_log_config_t) -> u32;
554    pub fn zvec_config_log_set_overdue_days(
555        config: *mut zvec_log_config_t,
556        days: u32,
557    ) -> zvec_error_code_t;
558
559    // -------------------------------------------------------------------------
560    // Global Configuration
561    // Functions for managing global system configuration.
562    // -------------------------------------------------------------------------
563    pub fn zvec_config_data_create() -> *mut zvec_config_data_t;
564    pub fn zvec_config_data_destroy(config: *mut zvec_config_data_t);
565    pub fn zvec_config_data_set_memory_limit(
566        config: *mut zvec_config_data_t,
567        memory_limit_bytes: u64,
568    ) -> zvec_error_code_t;
569    pub fn zvec_config_data_get_memory_limit(config: *const zvec_config_data_t) -> u64;
570    pub fn zvec_config_data_set_log_config(
571        config: *mut zvec_config_data_t,
572        log_config: *mut zvec_log_config_t,
573    ) -> zvec_error_code_t;
574    pub fn zvec_config_data_get_log_type(config: *const zvec_config_data_t) -> zvec_log_type_t;
575    pub fn zvec_config_data_set_query_thread_count(
576        config: *mut zvec_config_data_t,
577        thread_count: u32,
578    ) -> zvec_error_code_t;
579    pub fn zvec_config_data_get_query_thread_count(config: *const zvec_config_data_t) -> u32;
580    pub fn zvec_config_data_set_invert_to_forward_scan_ratio(
581        config: *mut zvec_config_data_t,
582        ratio: f32,
583    ) -> zvec_error_code_t;
584    pub fn zvec_config_data_get_invert_to_forward_scan_ratio(
585        config: *const zvec_config_data_t,
586    ) -> f32;
587    pub fn zvec_config_data_set_brute_force_by_keys_ratio(
588        config: *mut zvec_config_data_t,
589        ratio: f32,
590    ) -> zvec_error_code_t;
591    pub fn zvec_config_data_get_brute_force_by_keys_ratio(config: *const zvec_config_data_t)
592        -> f32;
593    pub fn zvec_config_data_set_fts_brute_force_by_keys_ratio(
594        config: *mut zvec_config_data_t,
595        ratio: f32,
596    ) -> zvec_error_code_t;
597    pub fn zvec_config_data_get_fts_brute_force_by_keys_ratio(
598        config: *const zvec_config_data_t,
599    ) -> f32;
600    pub fn zvec_config_data_set_optimize_thread_count(
601        config: *mut zvec_config_data_t,
602        thread_count: u32,
603    ) -> zvec_error_code_t;
604    pub fn zvec_config_data_get_optimize_thread_count(config: *const zvec_config_data_t) -> u32;
605    pub fn zvec_config_data_set_jieba_dict_dir(
606        config: *mut zvec_config_data_t,
607        dir: *const c_char,
608    ) -> zvec_error_code_t;
609    pub fn zvec_config_data_get_jieba_dict_dir(config: *const zvec_config_data_t) -> *const c_char;
610
611    // -------------------------------------------------------------------------
612    // Initialization
613    // Functions for initializing and shutting down the library.
614    // -------------------------------------------------------------------------
615    pub fn zvec_initialize(config: *const zvec_config_data_t) -> zvec_error_code_t;
616    pub fn zvec_shutdown() -> zvec_error_code_t;
617    pub fn zvec_is_initialized() -> bool;
618    pub fn zvec_set_default_jieba_dict_dir(dir: *const c_char);
619    pub fn zvec_get_default_jieba_dict_dir() -> *const c_char;
620
621    // -------------------------------------------------------------------------
622    // Index Parameters
623    // Functions for creating and configuring index parameters.
624    // -------------------------------------------------------------------------
625    pub fn zvec_index_params_create(index_type: zvec_index_type_t) -> *mut zvec_index_params_t;
626    pub fn zvec_index_params_destroy(params: *mut zvec_index_params_t);
627    pub fn zvec_index_params_get_type(params: *const zvec_index_params_t) -> zvec_index_type_t;
628    pub fn zvec_index_params_set_metric_type(
629        params: *mut zvec_index_params_t,
630        metric_type: zvec_metric_type_t,
631    ) -> zvec_error_code_t;
632    pub fn zvec_index_params_get_metric_type(
633        params: *const zvec_index_params_t,
634    ) -> zvec_metric_type_t;
635    pub fn zvec_index_params_set_quantize_type(
636        params: *mut zvec_index_params_t,
637        quantize_type: zvec_quantize_type_t,
638    ) -> zvec_error_code_t;
639    pub fn zvec_index_params_get_quantize_type(
640        params: *const zvec_index_params_t,
641    ) -> zvec_quantize_type_t;
642    pub fn zvec_index_params_set_hnsw_params(
643        params: *mut zvec_index_params_t,
644        m: c_int,
645        ef_construction: c_int,
646    ) -> zvec_error_code_t;
647    pub fn zvec_index_params_get_hnsw_m(params: *const zvec_index_params_t) -> c_int;
648    pub fn zvec_index_params_get_hnsw_ef_construction(params: *const zvec_index_params_t) -> c_int;
649    pub fn zvec_index_params_set_ivf_params(
650        params: *mut zvec_index_params_t,
651        n_list: c_int,
652        n_iters: c_int,
653        use_soar: bool,
654    ) -> zvec_error_code_t;
655    pub fn zvec_index_params_get_ivf_params(
656        params: *const zvec_index_params_t,
657        out_n_list: *mut c_int,
658        out_n_iters: *mut c_int,
659        out_use_soar: *mut bool,
660    ) -> zvec_error_code_t;
661    pub fn zvec_index_params_set_vamana_params(
662        params: *mut zvec_index_params_t,
663        max_degree: c_int,
664        search_list_size: c_int,
665        alpha: f32,
666        saturate_graph: bool,
667        use_contiguous_memory: bool,
668    ) -> zvec_error_code_t;
669    pub fn zvec_index_params_get_vamana_params(
670        params: *const zvec_index_params_t,
671        out_max_degree: *mut c_int,
672        out_search_list_size: *mut c_int,
673        out_alpha: *mut f32,
674        out_saturate_graph: *mut bool,
675        out_use_contiguous_memory: *mut bool,
676    ) -> zvec_error_code_t;
677    pub fn zvec_index_params_set_vamana_two_pass_build(
678        params: *mut zvec_index_params_t,
679        two_pass_build: bool,
680    ) -> zvec_error_code_t;
681    pub fn zvec_index_params_get_vamana_two_pass_build(params: *const zvec_index_params_t) -> bool;
682    pub fn zvec_index_params_set_diskann_params(
683        params: *mut zvec_index_params_t,
684        max_degree: c_int,
685        list_size: c_int,
686        pq_chunk_num: c_int,
687    ) -> zvec_error_code_t;
688    pub fn zvec_index_params_get_diskann_max_degree(params: *const zvec_index_params_t) -> c_int;
689    pub fn zvec_index_params_get_diskann_list_size(params: *const zvec_index_params_t) -> c_int;
690    pub fn zvec_index_params_get_diskann_pq_chunk_num(params: *const zvec_index_params_t) -> c_int;
691    pub fn zvec_index_params_set_ivf_rabitq_params(
692        params: *mut zvec_index_params_t,
693        nlist: c_int,
694        total_bits: c_int,
695        sample_count: c_int,
696    ) -> zvec_error_code_t;
697    pub fn zvec_index_params_get_ivf_rabitq_params(
698        params: *const zvec_index_params_t,
699        out_nlist: *mut c_int,
700        out_total_bits: *mut c_int,
701        out_sample_count: *mut c_int,
702    ) -> zvec_error_code_t;
703    pub fn zvec_index_params_set_invert_params(
704        params: *mut zvec_index_params_t,
705        enable_range_opt: bool,
706        enable_wildcard: bool,
707    ) -> zvec_error_code_t;
708    pub fn zvec_index_params_get_invert_params(
709        params: *const zvec_index_params_t,
710        out_enable_range_opt: *mut bool,
711        out_enable_wildcard: *mut bool,
712    ) -> zvec_error_code_t;
713    pub fn zvec_index_params_set_fts_params(
714        params: *mut zvec_index_params_t,
715        tokenizer_name: *const c_char,
716        filters: *const zvec_string_array_t,
717        extra_params: *const c_char,
718    ) -> zvec_error_code_t;
719    pub fn zvec_index_params_get_fts_params(
720        params: *const zvec_index_params_t,
721        out_tokenizer_name: *mut *const c_char,
722        out_filters: *mut *mut zvec_string_array_t,
723        out_extra_params: *mut *const c_char,
724    ) -> zvec_error_code_t;
725
726    // -------------------------------------------------------------------------
727    // Field Schema
728    // Functions for creating and managing field schema definitions.
729    // -------------------------------------------------------------------------
730    pub fn zvec_field_schema_create(
731        name: *const c_char,
732        data_type: zvec_data_type_t,
733        nullable: bool,
734        dimension: u32,
735    ) -> *mut zvec_field_schema_t;
736    pub fn zvec_field_schema_destroy(schema: *mut zvec_field_schema_t);
737    pub fn zvec_field_schema_set_name(
738        schema: *mut zvec_field_schema_t,
739        name: *const c_char,
740    ) -> zvec_error_code_t;
741    pub fn zvec_field_schema_get_name(schema: *const zvec_field_schema_t) -> *const c_char;
742    pub fn zvec_field_schema_get_data_type(schema: *const zvec_field_schema_t) -> zvec_data_type_t;
743    pub fn zvec_field_schema_set_data_type(
744        schema: *mut zvec_field_schema_t,
745        data_type: zvec_data_type_t,
746    ) -> zvec_error_code_t;
747    pub fn zvec_field_schema_get_element_data_type(
748        schema: *const zvec_field_schema_t,
749    ) -> zvec_data_type_t;
750    pub fn zvec_field_schema_get_element_data_size(schema: *const zvec_field_schema_t) -> usize;
751    pub fn zvec_field_schema_is_vector_field(schema: *const zvec_field_schema_t) -> bool;
752    pub fn zvec_field_schema_is_dense_vector(schema: *const zvec_field_schema_t) -> bool;
753    pub fn zvec_field_schema_is_sparse_vector(schema: *const zvec_field_schema_t) -> bool;
754    pub fn zvec_field_schema_is_nullable(schema: *const zvec_field_schema_t) -> bool;
755    pub fn zvec_field_schema_set_nullable(
756        schema: *mut zvec_field_schema_t,
757        nullable: bool,
758    ) -> zvec_error_code_t;
759    pub fn zvec_field_schema_has_invert_index(schema: *const zvec_field_schema_t) -> bool;
760    pub fn zvec_field_schema_is_array_type(schema: *const zvec_field_schema_t) -> bool;
761    pub fn zvec_field_schema_get_dimension(schema: *const zvec_field_schema_t) -> u32;
762    pub fn zvec_field_schema_set_dimension(
763        schema: *mut zvec_field_schema_t,
764        dimension: u32,
765    ) -> zvec_error_code_t;
766    pub fn zvec_field_schema_get_index_type(
767        schema: *const zvec_field_schema_t,
768    ) -> zvec_index_type_t;
769    pub fn zvec_field_schema_has_index(schema: *const zvec_field_schema_t) -> bool;
770    pub fn zvec_field_schema_get_index_params(
771        schema: *const zvec_field_schema_t,
772    ) -> *const zvec_index_params_t;
773    pub fn zvec_field_schema_set_index_params(
774        schema: *mut zvec_field_schema_t,
775        index_params: *const zvec_index_params_t,
776    ) -> zvec_error_code_t;
777    pub fn zvec_field_schema_validate(
778        schema: *const zvec_field_schema_t,
779        error_msg: *mut *mut zvec_string_t,
780    ) -> zvec_error_code_t;
781
782    // -------------------------------------------------------------------------
783    // Collection Schema
784    // Functions for creating and managing collection schema definitions.
785    // -------------------------------------------------------------------------
786    pub fn zvec_collection_schema_create(name: *const c_char) -> *mut zvec_collection_schema_t;
787    pub fn zvec_collection_schema_destroy(schema: *mut zvec_collection_schema_t);
788    pub fn zvec_collection_schema_get_name(
789        schema: *const zvec_collection_schema_t,
790    ) -> *const c_char;
791    pub fn zvec_collection_schema_set_name(
792        schema: *mut zvec_collection_schema_t,
793        name: *const c_char,
794    ) -> zvec_error_code_t;
795    pub fn zvec_collection_schema_add_field(
796        schema: *mut zvec_collection_schema_t,
797        field: *const zvec_field_schema_t,
798    ) -> zvec_error_code_t;
799    pub fn zvec_collection_schema_alter_field(
800        schema: *mut zvec_collection_schema_t,
801        field_name: *const c_char,
802        new_field: *const zvec_field_schema_t,
803    ) -> zvec_error_code_t;
804    pub fn zvec_collection_schema_drop_field(
805        schema: *mut zvec_collection_schema_t,
806        field_name: *const c_char,
807    ) -> zvec_error_code_t;
808    pub fn zvec_collection_schema_has_field(
809        schema: *const zvec_collection_schema_t,
810        field_name: *const c_char,
811    ) -> bool;
812    pub fn zvec_collection_schema_get_field(
813        schema: *const zvec_collection_schema_t,
814        field_name: *const c_char,
815    ) -> *mut zvec_field_schema_t;
816    pub fn zvec_collection_schema_get_forward_field(
817        schema: *const zvec_collection_schema_t,
818        field_name: *const c_char,
819    ) -> *mut zvec_field_schema_t;
820    pub fn zvec_collection_schema_get_vector_field(
821        schema: *const zvec_collection_schema_t,
822        field_name: *const c_char,
823    ) -> *mut zvec_field_schema_t;
824    pub fn zvec_collection_schema_get_forward_fields(
825        schema: *const zvec_collection_schema_t,
826        fields: *mut *mut *mut zvec_field_schema_t,
827        count: *mut usize,
828    ) -> zvec_error_code_t;
829    pub fn zvec_collection_schema_get_forward_fields_with_index(
830        schema: *const zvec_collection_schema_t,
831        fields: *mut *mut *mut zvec_field_schema_t,
832        count: *mut usize,
833    ) -> zvec_error_code_t;
834    pub fn zvec_collection_schema_get_forward_field_names(
835        schema: *const zvec_collection_schema_t,
836        names: *mut *mut *const c_char,
837        count: *mut usize,
838    ) -> zvec_error_code_t;
839    pub fn zvec_collection_schema_get_forward_field_names_with_index(
840        schema: *const zvec_collection_schema_t,
841        names: *mut *mut *const c_char,
842        count: *mut usize,
843    ) -> zvec_error_code_t;
844    pub fn zvec_collection_schema_get_all_field_names(
845        schema: *const zvec_collection_schema_t,
846        names: *mut *mut *const c_char,
847        count: *mut usize,
848    ) -> zvec_error_code_t;
849    pub fn zvec_collection_schema_get_vector_fields(
850        schema: *const zvec_collection_schema_t,
851        fields: *mut *mut *mut zvec_field_schema_t,
852        count: *mut usize,
853    ) -> zvec_error_code_t;
854    pub fn zvec_collection_schema_get_max_doc_count_per_segment(
855        schema: *const zvec_collection_schema_t,
856    ) -> u64;
857    pub fn zvec_collection_schema_set_max_doc_count_per_segment(
858        schema: *mut zvec_collection_schema_t,
859        max_doc_count: u64,
860    ) -> zvec_error_code_t;
861    pub fn zvec_collection_schema_validate(
862        schema: *const zvec_collection_schema_t,
863        error_msg: *mut *mut zvec_string_t,
864    ) -> zvec_error_code_t;
865    pub fn zvec_collection_schema_add_index(
866        schema: *mut zvec_collection_schema_t,
867        field_name: *const c_char,
868        index_params: *const zvec_index_params_t,
869    ) -> zvec_error_code_t;
870    pub fn zvec_collection_schema_drop_index(
871        schema: *mut zvec_collection_schema_t,
872        field_name: *const c_char,
873    ) -> zvec_error_code_t;
874    pub fn zvec_collection_schema_has_index(
875        schema: *const zvec_collection_schema_t,
876        field_name: *const c_char,
877    ) -> bool;
878
879    // -------------------------------------------------------------------------
880    // Collection Options
881    // Functions for configuring collection opening options.
882    // -------------------------------------------------------------------------
883    pub fn zvec_collection_options_create() -> *mut zvec_collection_options_t;
884    pub fn zvec_collection_options_destroy(options: *mut zvec_collection_options_t);
885    pub fn zvec_collection_options_set_enable_mmap(
886        options: *mut zvec_collection_options_t,
887        enable: bool,
888    ) -> zvec_error_code_t;
889    pub fn zvec_collection_options_get_enable_mmap(
890        options: *const zvec_collection_options_t,
891    ) -> bool;
892    pub fn zvec_collection_options_set_max_buffer_size(
893        options: *mut zvec_collection_options_t,
894        size: usize,
895    ) -> zvec_error_code_t;
896    pub fn zvec_collection_options_get_max_buffer_size(
897        options: *const zvec_collection_options_t,
898    ) -> usize;
899    pub fn zvec_collection_options_set_read_only(
900        options: *mut zvec_collection_options_t,
901        read_only: bool,
902    ) -> zvec_error_code_t;
903    pub fn zvec_collection_options_get_read_only(options: *const zvec_collection_options_t)
904        -> bool;
905
906    // -------------------------------------------------------------------------
907    // Collection Statistics
908    // Functions for retrieving collection statistics.
909    // -------------------------------------------------------------------------
910    pub fn zvec_collection_stats_get_doc_count(stats: *const zvec_collection_stats_t) -> u64;
911    pub fn zvec_collection_stats_get_index_count(stats: *const zvec_collection_stats_t) -> usize;
912    pub fn zvec_collection_stats_get_index_name(
913        stats: *const zvec_collection_stats_t,
914        index: usize,
915    ) -> *const c_char;
916    pub fn zvec_collection_stats_get_index_completeness(
917        stats: *const zvec_collection_stats_t,
918        index: usize,
919    ) -> f32;
920    pub fn zvec_collection_stats_destroy(stats: *mut zvec_collection_stats_t);
921
922    // -------------------------------------------------------------------------
923    // Collection Management
924    // Functions for creating, opening, closing, and destroying collections.
925    // -------------------------------------------------------------------------
926    pub fn zvec_collection_create_and_open(
927        path: *const c_char,
928        schema: *const zvec_collection_schema_t,
929        options: *const zvec_collection_options_t,
930        collection: *mut *mut zvec_collection_t,
931    ) -> zvec_error_code_t;
932    pub fn zvec_collection_open(
933        path: *const c_char,
934        options: *const zvec_collection_options_t,
935        collection: *mut *mut zvec_collection_t,
936    ) -> zvec_error_code_t;
937    pub fn zvec_collection_close(collection: *mut zvec_collection_t) -> zvec_error_code_t;
938    pub fn zvec_collection_destroy(collection: *mut zvec_collection_t) -> zvec_error_code_t;
939    pub fn zvec_collection_flush(collection: *mut zvec_collection_t) -> zvec_error_code_t;
940    pub fn zvec_collection_get_schema(
941        collection: *const zvec_collection_t,
942        schema: *mut *mut zvec_collection_schema_t,
943    ) -> zvec_error_code_t;
944    pub fn zvec_collection_get_options(
945        collection: *const zvec_collection_t,
946        options: *mut *mut zvec_collection_options_t,
947    ) -> zvec_error_code_t;
948    pub fn zvec_collection_get_stats(
949        collection: *const zvec_collection_t,
950        stats: *mut *mut zvec_collection_stats_t,
951    ) -> zvec_error_code_t;
952    pub fn zvec_free_field_schema(field_schema: *mut zvec_field_schema_t);
953
954    // -------------------------------------------------------------------------
955    // Index Management
956    // Functions for creating, dropping, and optimizing indexes.
957    // -------------------------------------------------------------------------
958    pub fn zvec_collection_create_index(
959        collection: *mut zvec_collection_t,
960        field_name: *const c_char,
961        index_params: *const zvec_index_params_t,
962    ) -> zvec_error_code_t;
963    pub fn zvec_collection_drop_index(
964        collection: *mut zvec_collection_t,
965        field_name: *const c_char,
966    ) -> zvec_error_code_t;
967    pub fn zvec_collection_optimize(collection: *mut zvec_collection_t) -> zvec_error_code_t;
968
969    // -------------------------------------------------------------------------
970    // Column Management (DDL)
971    // Functions for adding, dropping, and altering columns (schema changes).
972    // -------------------------------------------------------------------------
973    pub fn zvec_collection_add_column(
974        collection: *mut zvec_collection_t,
975        field_schema: *const zvec_field_schema_t,
976        expression: *const c_char,
977    ) -> zvec_error_code_t;
978    pub fn zvec_collection_drop_column(
979        collection: *mut zvec_collection_t,
980        column_name: *const c_char,
981    ) -> zvec_error_code_t;
982    pub fn zvec_collection_alter_column(
983        collection: *mut zvec_collection_t,
984        column_name: *const c_char,
985        new_name: *const c_char,
986        new_schema: *const zvec_field_schema_t,
987    ) -> zvec_error_code_t;
988
989    // -------------------------------------------------------------------------
990    // DML
991    // Functions for data manipulation: insert, update, upsert, and delete operations.
992    // -------------------------------------------------------------------------
993    pub fn zvec_collection_insert(
994        collection: *mut zvec_collection_t,
995        docs: *const *const zvec_doc_t,
996        doc_count: usize,
997        success_count: *mut usize,
998        error_count: *mut usize,
999    ) -> zvec_error_code_t;
1000    pub fn zvec_collection_insert_with_results(
1001        collection: *mut zvec_collection_t,
1002        docs: *const *const zvec_doc_t,
1003        doc_count: usize,
1004        results: *mut *mut zvec_write_result_t,
1005        result_count: *mut usize,
1006    ) -> zvec_error_code_t;
1007    pub fn zvec_collection_update(
1008        collection: *mut zvec_collection_t,
1009        docs: *const *const zvec_doc_t,
1010        doc_count: usize,
1011        success_count: *mut usize,
1012        error_count: *mut usize,
1013    ) -> zvec_error_code_t;
1014    pub fn zvec_collection_update_with_results(
1015        collection: *mut zvec_collection_t,
1016        docs: *const *const zvec_doc_t,
1017        doc_count: usize,
1018        results: *mut *mut zvec_write_result_t,
1019        result_count: *mut usize,
1020    ) -> zvec_error_code_t;
1021    pub fn zvec_collection_upsert(
1022        collection: *mut zvec_collection_t,
1023        docs: *const *const zvec_doc_t,
1024        doc_count: usize,
1025        success_count: *mut usize,
1026        error_count: *mut usize,
1027    ) -> zvec_error_code_t;
1028    pub fn zvec_collection_upsert_with_results(
1029        collection: *mut zvec_collection_t,
1030        docs: *const *const zvec_doc_t,
1031        doc_count: usize,
1032        results: *mut *mut zvec_write_result_t,
1033        result_count: *mut usize,
1034    ) -> zvec_error_code_t;
1035    pub fn zvec_collection_delete(
1036        collection: *mut zvec_collection_t,
1037        pks: *const *const c_char,
1038        pk_count: usize,
1039        success_count: *mut usize,
1040        error_count: *mut usize,
1041    ) -> zvec_error_code_t;
1042    pub fn zvec_collection_delete_with_results(
1043        collection: *mut zvec_collection_t,
1044        pks: *const *const c_char,
1045        pk_count: usize,
1046        results: *mut *mut zvec_write_result_t,
1047        result_count: *mut usize,
1048    ) -> zvec_error_code_t;
1049    pub fn zvec_write_results_free(results: *mut zvec_write_result_t, result_count: usize);
1050    pub fn zvec_collection_delete_by_filter(
1051        collection: *mut zvec_collection_t,
1052        filter: *const c_char,
1053    ) -> zvec_error_code_t;
1054
1055    // -------------------------------------------------------------------------
1056    // DQL
1057    // Functions for data querying: vector search and document fetch operations.
1058    // -------------------------------------------------------------------------
1059    pub fn zvec_collection_query(
1060        collection: *const zvec_collection_t,
1061        query: *const zvec_vector_query_t,
1062        results: *mut *mut *mut zvec_doc_t,
1063        result_count: *mut usize,
1064    ) -> zvec_error_code_t;
1065    pub fn zvec_collection_multi_query(
1066        collection: *const zvec_collection_t,
1067        query: *const zvec_multi_query_t,
1068        results: *mut *mut *mut zvec_doc_t,
1069        result_count: *mut usize,
1070    ) -> zvec_error_code_t;
1071    pub fn zvec_collection_fetch(
1072        collection: *mut zvec_collection_t,
1073        primary_keys: *const *const c_char,
1074        count: usize,
1075        output_fields: *const *const c_char,
1076        output_field_count: usize,
1077        include_vector: bool,
1078        documents: *mut *mut *mut zvec_doc_t,
1079        found_count: *mut usize,
1080    ) -> zvec_error_code_t;
1081
1082    // -------------------------------------------------------------------------
1083    // Document Iterator
1084    // Functions for full collection traversal over an isolated snapshot.
1085    // -------------------------------------------------------------------------
1086    pub fn zvec_iterator_options_create() -> *mut zvec_iterator_options_t;
1087    pub fn zvec_iterator_options_destroy(options: *mut zvec_iterator_options_t);
1088    pub fn zvec_iterator_options_set_output_fields(
1089        options: *mut zvec_iterator_options_t,
1090        output_fields: *const *const c_char,
1091        count: usize,
1092    ) -> zvec_error_code_t;
1093    pub fn zvec_iterator_options_set_include_vector(
1094        options: *mut zvec_iterator_options_t,
1095        include: bool,
1096    ) -> zvec_error_code_t;
1097    pub fn zvec_collection_create_iterator(
1098        collection: *mut zvec_collection_t,
1099        options: *const zvec_iterator_options_t,
1100        out_iter: *mut *mut zvec_doc_iterator_t,
1101    ) -> zvec_error_code_t;
1102    pub fn zvec_doc_iterator_next(
1103        iter: *mut zvec_doc_iterator_t,
1104        out_doc: *mut *mut zvec_doc_t,
1105    ) -> zvec_error_code_t;
1106    pub fn zvec_doc_iterator_close(iter: *mut zvec_doc_iterator_t);
1107
1108    // -------------------------------------------------------------------------
1109    // HNSW Query Parameters
1110    // Functions for creating and configuring HNSW index query parameters.
1111    // -------------------------------------------------------------------------
1112    pub fn zvec_query_params_hnsw_create(
1113        ef: c_int,
1114        radius: f32,
1115        is_linear: bool,
1116        is_using_refiner: bool,
1117    ) -> *mut zvec_hnsw_query_params_t;
1118    pub fn zvec_query_params_hnsw_destroy(params: *mut zvec_hnsw_query_params_t);
1119    pub fn zvec_query_params_hnsw_set_ef(
1120        params: *mut zvec_hnsw_query_params_t,
1121        ef: c_int,
1122    ) -> zvec_error_code_t;
1123    pub fn zvec_query_params_hnsw_get_ef(params: *const zvec_hnsw_query_params_t) -> c_int;
1124    pub fn zvec_query_params_hnsw_set_radius(
1125        params: *mut zvec_hnsw_query_params_t,
1126        radius: f32,
1127    ) -> zvec_error_code_t;
1128    pub fn zvec_query_params_hnsw_get_radius(params: *const zvec_hnsw_query_params_t) -> f32;
1129    pub fn zvec_query_params_hnsw_set_is_linear(
1130        params: *mut zvec_hnsw_query_params_t,
1131        is_linear: bool,
1132    ) -> zvec_error_code_t;
1133    pub fn zvec_query_params_hnsw_get_is_linear(params: *const zvec_hnsw_query_params_t) -> bool;
1134    pub fn zvec_query_params_hnsw_set_is_using_refiner(
1135        params: *mut zvec_hnsw_query_params_t,
1136        is_using_refiner: bool,
1137    ) -> zvec_error_code_t;
1138    pub fn zvec_query_params_hnsw_get_is_using_refiner(
1139        params: *const zvec_hnsw_query_params_t,
1140    ) -> bool;
1141
1142    // -------------------------------------------------------------------------
1143    // IVF Query Parameters
1144    // Functions for creating and configuring IVF index query parameters.
1145    // -------------------------------------------------------------------------
1146    pub fn zvec_query_params_ivf_create(
1147        nprobe: c_int,
1148        is_using_refiner: bool,
1149        scale_factor: f32,
1150    ) -> *mut zvec_ivf_query_params_t;
1151    pub fn zvec_query_params_ivf_destroy(params: *mut zvec_ivf_query_params_t);
1152    pub fn zvec_query_params_ivf_set_nprobe(
1153        params: *mut zvec_ivf_query_params_t,
1154        nprobe: c_int,
1155    ) -> zvec_error_code_t;
1156    pub fn zvec_query_params_ivf_get_nprobe(params: *const zvec_ivf_query_params_t) -> c_int;
1157    pub fn zvec_query_params_ivf_set_scale_factor(
1158        params: *mut zvec_ivf_query_params_t,
1159        scale_factor: f32,
1160    ) -> zvec_error_code_t;
1161    pub fn zvec_query_params_ivf_get_scale_factor(params: *const zvec_ivf_query_params_t) -> f32;
1162    pub fn zvec_query_params_ivf_set_radius(
1163        params: *mut zvec_ivf_query_params_t,
1164        radius: f32,
1165    ) -> zvec_error_code_t;
1166    pub fn zvec_query_params_ivf_get_radius(params: *const zvec_ivf_query_params_t) -> f32;
1167    pub fn zvec_query_params_ivf_set_is_linear(
1168        params: *mut zvec_ivf_query_params_t,
1169        is_linear: bool,
1170    ) -> zvec_error_code_t;
1171    pub fn zvec_query_params_ivf_get_is_linear(params: *const zvec_ivf_query_params_t) -> bool;
1172    pub fn zvec_query_params_ivf_set_is_using_refiner(
1173        params: *mut zvec_ivf_query_params_t,
1174        is_using_refiner: bool,
1175    ) -> zvec_error_code_t;
1176    pub fn zvec_query_params_ivf_get_is_using_refiner(
1177        params: *const zvec_ivf_query_params_t,
1178    ) -> bool;
1179
1180    // -------------------------------------------------------------------------
1181    // IVF RaBitQ Query Parameters
1182    // Functions for creating and configuring IVF RaBitQ index query parameters.
1183    // -------------------------------------------------------------------------
1184    pub fn zvec_query_params_ivf_rabitq_create(
1185        nprobe: c_int,
1186        radius: f32,
1187        is_linear: bool,
1188        is_using_refiner: bool,
1189    ) -> *mut zvec_ivf_rabitq_query_params_t;
1190    pub fn zvec_query_params_ivf_rabitq_destroy(params: *mut zvec_ivf_rabitq_query_params_t);
1191    pub fn zvec_query_params_ivf_rabitq_set_nprobe(
1192        params: *mut zvec_ivf_rabitq_query_params_t,
1193        nprobe: c_int,
1194    ) -> zvec_error_code_t;
1195    pub fn zvec_query_params_ivf_rabitq_get_nprobe(
1196        params: *const zvec_ivf_rabitq_query_params_t,
1197    ) -> c_int;
1198    pub fn zvec_query_params_ivf_rabitq_set_scale_factor(
1199        params: *mut zvec_ivf_rabitq_query_params_t,
1200        scale_factor: f32,
1201    ) -> zvec_error_code_t;
1202    pub fn zvec_query_params_ivf_rabitq_get_scale_factor(
1203        params: *const zvec_ivf_rabitq_query_params_t,
1204    ) -> f32;
1205    pub fn zvec_query_params_ivf_rabitq_set_radius(
1206        params: *mut zvec_ivf_rabitq_query_params_t,
1207        radius: f32,
1208    ) -> zvec_error_code_t;
1209    pub fn zvec_query_params_ivf_rabitq_get_radius(
1210        params: *const zvec_ivf_rabitq_query_params_t,
1211    ) -> f32;
1212    pub fn zvec_query_params_ivf_rabitq_set_is_linear(
1213        params: *mut zvec_ivf_rabitq_query_params_t,
1214        is_linear: bool,
1215    ) -> zvec_error_code_t;
1216    pub fn zvec_query_params_ivf_rabitq_get_is_linear(
1217        params: *const zvec_ivf_rabitq_query_params_t,
1218    ) -> bool;
1219    pub fn zvec_query_params_ivf_rabitq_set_is_using_refiner(
1220        params: *mut zvec_ivf_rabitq_query_params_t,
1221        is_using_refiner: bool,
1222    ) -> zvec_error_code_t;
1223    pub fn zvec_query_params_ivf_rabitq_get_is_using_refiner(
1224        params: *const zvec_ivf_rabitq_query_params_t,
1225    ) -> bool;
1226
1227    // -------------------------------------------------------------------------
1228    // Flat Query Parameters
1229    // Functions for creating and configuring flat index query parameters.
1230    // -------------------------------------------------------------------------
1231    pub fn zvec_query_params_flat_create(
1232        is_using_refiner: bool,
1233        scale_factor: f32,
1234    ) -> *mut zvec_flat_query_params_t;
1235    pub fn zvec_query_params_flat_destroy(params: *mut zvec_flat_query_params_t);
1236    pub fn zvec_query_params_flat_set_scale_factor(
1237        params: *mut zvec_flat_query_params_t,
1238        scale_factor: f32,
1239    ) -> zvec_error_code_t;
1240    pub fn zvec_query_params_flat_get_scale_factor(params: *const zvec_flat_query_params_t) -> f32;
1241    pub fn zvec_query_params_flat_set_radius(
1242        params: *mut zvec_flat_query_params_t,
1243        radius: f32,
1244    ) -> zvec_error_code_t;
1245    pub fn zvec_query_params_flat_get_radius(params: *const zvec_flat_query_params_t) -> f32;
1246    pub fn zvec_query_params_flat_set_is_linear(
1247        params: *mut zvec_flat_query_params_t,
1248        is_linear: bool,
1249    ) -> zvec_error_code_t;
1250    pub fn zvec_query_params_flat_get_is_linear(params: *const zvec_flat_query_params_t) -> bool;
1251    pub fn zvec_query_params_flat_set_is_using_refiner(
1252        params: *mut zvec_flat_query_params_t,
1253        is_using_refiner: bool,
1254    ) -> zvec_error_code_t;
1255    pub fn zvec_query_params_flat_get_is_using_refiner(
1256        params: *const zvec_flat_query_params_t,
1257    ) -> bool;
1258
1259    // -------------------------------------------------------------------------
1260    // Vamana Query Parameters
1261    // Functions for creating and configuring Vamana query parameters.
1262    // -------------------------------------------------------------------------
1263    pub fn zvec_query_params_vamana_create(
1264        ef_search: c_int,
1265        radius: f32,
1266        is_linear: bool,
1267        is_using_refiner: bool,
1268    ) -> *mut zvec_vamana_query_params_t;
1269    pub fn zvec_query_params_vamana_destroy(params: *mut zvec_vamana_query_params_t);
1270    pub fn zvec_query_params_vamana_set_ef_search(
1271        params: *mut zvec_vamana_query_params_t,
1272        ef_search: c_int,
1273    ) -> zvec_error_code_t;
1274    pub fn zvec_query_params_vamana_get_ef_search(
1275        params: *const zvec_vamana_query_params_t,
1276    ) -> c_int;
1277    pub fn zvec_query_params_vamana_set_radius(
1278        params: *mut zvec_vamana_query_params_t,
1279        radius: f32,
1280    ) -> zvec_error_code_t;
1281    pub fn zvec_query_params_vamana_get_radius(params: *const zvec_vamana_query_params_t) -> f32;
1282    pub fn zvec_query_params_vamana_set_is_linear(
1283        params: *mut zvec_vamana_query_params_t,
1284        is_linear: bool,
1285    ) -> zvec_error_code_t;
1286    pub fn zvec_query_params_vamana_get_is_linear(
1287        params: *const zvec_vamana_query_params_t,
1288    ) -> bool;
1289    pub fn zvec_query_params_vamana_set_is_using_refiner(
1290        params: *mut zvec_vamana_query_params_t,
1291        is_using_refiner: bool,
1292    ) -> zvec_error_code_t;
1293    pub fn zvec_query_params_vamana_get_is_using_refiner(
1294        params: *const zvec_vamana_query_params_t,
1295    ) -> bool;
1296
1297    // -------------------------------------------------------------------------
1298    // DiskANN Query Parameters
1299    // Functions for creating and configuring DiskANN query parameters.
1300    // -------------------------------------------------------------------------
1301    pub fn zvec_query_params_diskann_create(list_size: c_int) -> *mut zvec_diskann_query_params_t;
1302    pub fn zvec_query_params_diskann_destroy(params: *mut zvec_diskann_query_params_t);
1303    pub fn zvec_query_params_diskann_set_list_size(
1304        params: *mut zvec_diskann_query_params_t,
1305        list_size: c_int,
1306    ) -> zvec_error_code_t;
1307    pub fn zvec_query_params_diskann_get_list_size(
1308        params: *const zvec_diskann_query_params_t,
1309    ) -> c_int;
1310    pub fn zvec_query_params_diskann_set_radius(
1311        params: *mut zvec_diskann_query_params_t,
1312        radius: f32,
1313    ) -> zvec_error_code_t;
1314    pub fn zvec_query_params_diskann_get_radius(params: *const zvec_diskann_query_params_t) -> f32;
1315    pub fn zvec_query_params_diskann_set_is_linear(
1316        params: *mut zvec_diskann_query_params_t,
1317        is_linear: bool,
1318    ) -> zvec_error_code_t;
1319    pub fn zvec_query_params_diskann_get_is_linear(
1320        params: *const zvec_diskann_query_params_t,
1321    ) -> bool;
1322    pub fn zvec_query_params_diskann_set_is_using_refiner(
1323        params: *mut zvec_diskann_query_params_t,
1324        is_using_refiner: bool,
1325    ) -> zvec_error_code_t;
1326    pub fn zvec_query_params_diskann_get_is_using_refiner(
1327        params: *const zvec_diskann_query_params_t,
1328    ) -> bool;
1329
1330    // -------------------------------------------------------------------------
1331    // FTS Query Parameters
1332    // Functions for creating and configuring FTS query parameters.
1333    // -------------------------------------------------------------------------
1334    pub fn zvec_query_params_fts_create(
1335        default_operator: *const c_char,
1336    ) -> *mut zvec_fts_query_params_t;
1337    pub fn zvec_query_params_fts_destroy(params: *mut zvec_fts_query_params_t);
1338    pub fn zvec_query_params_fts_set_default_operator(
1339        params: *mut zvec_fts_query_params_t,
1340        default_operator: *const c_char,
1341    ) -> zvec_error_code_t;
1342    pub fn zvec_query_params_fts_get_default_operator(
1343        params: *const zvec_fts_query_params_t,
1344    ) -> *const c_char;
1345
1346    // -------------------------------------------------------------------------
1347    // FTS Query Payload
1348    // Functions for creating and configuring FTS query payloads.
1349    // -------------------------------------------------------------------------
1350    pub fn zvec_fts_create() -> *mut zvec_fts_t;
1351    pub fn zvec_fts_destroy(fts: *mut zvec_fts_t);
1352    pub fn zvec_fts_set_query_string(
1353        fts: *mut zvec_fts_t,
1354        query_string: *const c_char,
1355    ) -> zvec_error_code_t;
1356    pub fn zvec_fts_set_match_string(
1357        fts: *mut zvec_fts_t,
1358        match_string: *const c_char,
1359    ) -> zvec_error_code_t;
1360    pub fn zvec_fts_get_query_string(fts: *const zvec_fts_t) -> *const c_char;
1361    pub fn zvec_fts_get_match_string(fts: *const zvec_fts_t) -> *const c_char;
1362
1363    // -------------------------------------------------------------------------
1364    // Vector Query
1365    // Functions for creating and configuring vector similarity queries.
1366    // -------------------------------------------------------------------------
1367    pub fn zvec_vector_query_create() -> *mut zvec_vector_query_t;
1368    pub fn zvec_vector_query_destroy(query: *mut zvec_vector_query_t);
1369    pub fn zvec_vector_query_set_topk(
1370        query: *mut zvec_vector_query_t,
1371        topk: c_int,
1372    ) -> zvec_error_code_t;
1373    pub fn zvec_vector_query_get_topk(query: *const zvec_vector_query_t) -> c_int;
1374    pub fn zvec_vector_query_set_field_name(
1375        query: *mut zvec_vector_query_t,
1376        field_name: *const c_char,
1377    ) -> zvec_error_code_t;
1378    pub fn zvec_vector_query_get_field_name(query: *const zvec_vector_query_t) -> *const c_char;
1379    pub fn zvec_vector_query_set_query_vector(
1380        query: *mut zvec_vector_query_t,
1381        data: *const c_void,
1382        size: usize,
1383    ) -> zvec_error_code_t;
1384    pub fn zvec_vector_query_set_filter(
1385        query: *mut zvec_vector_query_t,
1386        filter: *const c_char,
1387    ) -> zvec_error_code_t;
1388    pub fn zvec_vector_query_get_filter(query: *const zvec_vector_query_t) -> *const c_char;
1389    pub fn zvec_vector_query_set_include_vector(
1390        query: *mut zvec_vector_query_t,
1391        include: bool,
1392    ) -> zvec_error_code_t;
1393    pub fn zvec_vector_query_get_include_vector(query: *const zvec_vector_query_t) -> bool;
1394    pub fn zvec_vector_query_set_include_doc_id(
1395        query: *mut zvec_vector_query_t,
1396        include: bool,
1397    ) -> zvec_error_code_t;
1398    pub fn zvec_vector_query_get_include_doc_id(query: *const zvec_vector_query_t) -> bool;
1399    pub fn zvec_vector_query_set_output_fields(
1400        query: *mut zvec_vector_query_t,
1401        fields: *const *const c_char,
1402        count: usize,
1403    ) -> zvec_error_code_t;
1404    pub fn zvec_vector_query_get_output_fields(
1405        query: *const zvec_vector_query_t,
1406        fields: *mut *mut *const c_char,
1407        count: *mut usize,
1408    ) -> zvec_error_code_t;
1409    pub fn zvec_vector_query_set_query_params(
1410        query: *mut zvec_vector_query_t,
1411        params: *mut c_void,
1412    ) -> zvec_error_code_t;
1413    pub fn zvec_vector_query_set_hnsw_params(
1414        query: *mut zvec_vector_query_t,
1415        hnsw_params: *mut zvec_hnsw_query_params_t,
1416    ) -> zvec_error_code_t;
1417    pub fn zvec_vector_query_set_ivf_params(
1418        query: *mut zvec_vector_query_t,
1419        ivf_params: *mut zvec_ivf_query_params_t,
1420    ) -> zvec_error_code_t;
1421    pub fn zvec_vector_query_set_ivf_rabitq_params(
1422        query: *mut zvec_vector_query_t,
1423        ivf_rabitq_params: *mut zvec_ivf_rabitq_query_params_t,
1424    ) -> zvec_error_code_t;
1425    pub fn zvec_vector_query_set_flat_params(
1426        query: *mut zvec_vector_query_t,
1427        flat_params: *mut zvec_flat_query_params_t,
1428    ) -> zvec_error_code_t;
1429    pub fn zvec_vector_query_set_vamana_params(
1430        query: *mut zvec_vector_query_t,
1431        vamana_params: *mut zvec_vamana_query_params_t,
1432    ) -> zvec_error_code_t;
1433    pub fn zvec_vector_query_set_diskann_params(
1434        query: *mut zvec_vector_query_t,
1435        diskann_params: *mut zvec_diskann_query_params_t,
1436    ) -> zvec_error_code_t;
1437    pub fn zvec_vector_query_set_fts_params(
1438        query: *mut zvec_vector_query_t,
1439        fts_params: *mut zvec_fts_query_params_t,
1440    ) -> zvec_error_code_t;
1441    pub fn zvec_vector_query_set_fts(
1442        query: *mut zvec_vector_query_t,
1443        fts: *const zvec_fts_t,
1444    ) -> zvec_error_code_t;
1445    pub fn zvec_vector_query_get_fts(query: *const zvec_vector_query_t) -> *const zvec_fts_t;
1446
1447    // -------------------------------------------------------------------------
1448    // Group By Vector Query
1449    // Functions for creating and configuring grouped vector queries.
1450    // -------------------------------------------------------------------------
1451    pub fn zvec_group_by_vector_query_create() -> *mut zvec_group_by_vector_query_t;
1452    pub fn zvec_group_by_vector_query_destroy(query: *mut zvec_group_by_vector_query_t);
1453    pub fn zvec_group_by_vector_query_set_field_name(
1454        query: *mut zvec_group_by_vector_query_t,
1455        field_name: *const c_char,
1456    ) -> zvec_error_code_t;
1457    pub fn zvec_group_by_vector_query_get_field_name(
1458        query: *const zvec_group_by_vector_query_t,
1459    ) -> *const c_char;
1460    pub fn zvec_group_by_vector_query_set_group_by_field_name(
1461        query: *mut zvec_group_by_vector_query_t,
1462        field_name: *const c_char,
1463    ) -> zvec_error_code_t;
1464    pub fn zvec_group_by_vector_query_get_group_by_field_name(
1465        query: *const zvec_group_by_vector_query_t,
1466    ) -> *const c_char;
1467    pub fn zvec_group_by_vector_query_set_group_count(
1468        query: *mut zvec_group_by_vector_query_t,
1469        count: u32,
1470    ) -> zvec_error_code_t;
1471    pub fn zvec_group_by_vector_query_get_group_count(
1472        query: *const zvec_group_by_vector_query_t,
1473    ) -> u32;
1474    pub fn zvec_group_by_vector_query_set_topk_per_group(
1475        query: *mut zvec_group_by_vector_query_t,
1476        topk: u32,
1477    ) -> zvec_error_code_t;
1478    pub fn zvec_group_by_vector_query_get_topk_per_group(
1479        query: *const zvec_group_by_vector_query_t,
1480    ) -> u32;
1481    pub fn zvec_group_by_vector_query_set_query_vector(
1482        query: *mut zvec_group_by_vector_query_t,
1483        data: *const c_void,
1484        size: usize,
1485    ) -> zvec_error_code_t;
1486    pub fn zvec_group_by_vector_query_set_filter(
1487        query: *mut zvec_group_by_vector_query_t,
1488        filter: *const c_char,
1489    ) -> zvec_error_code_t;
1490    pub fn zvec_group_by_vector_query_get_filter(
1491        query: *const zvec_group_by_vector_query_t,
1492    ) -> *const c_char;
1493    pub fn zvec_group_by_vector_query_set_include_vector(
1494        query: *mut zvec_group_by_vector_query_t,
1495        include: bool,
1496    ) -> zvec_error_code_t;
1497    pub fn zvec_group_by_vector_query_get_include_vector(
1498        query: *const zvec_group_by_vector_query_t,
1499    ) -> bool;
1500    pub fn zvec_group_by_vector_query_set_output_fields(
1501        query: *mut zvec_group_by_vector_query_t,
1502        fields: *const *const c_char,
1503        count: usize,
1504    ) -> zvec_error_code_t;
1505    pub fn zvec_group_by_vector_query_get_output_fields(
1506        query: *mut zvec_group_by_vector_query_t,
1507        fields: *mut *mut *const c_char,
1508        count: *mut usize,
1509    ) -> zvec_error_code_t;
1510    pub fn zvec_group_by_vector_query_set_query_params(
1511        query: *mut zvec_group_by_vector_query_t,
1512        params: *mut c_void,
1513    ) -> zvec_error_code_t;
1514    pub fn zvec_group_by_vector_query_set_hnsw_params(
1515        query: *mut zvec_group_by_vector_query_t,
1516        hnsw_params: *mut zvec_hnsw_query_params_t,
1517    ) -> zvec_error_code_t;
1518    pub fn zvec_group_by_vector_query_set_ivf_params(
1519        query: *mut zvec_group_by_vector_query_t,
1520        ivf_params: *mut zvec_ivf_query_params_t,
1521    ) -> zvec_error_code_t;
1522    pub fn zvec_group_by_vector_query_set_ivf_rabitq_params(
1523        query: *mut zvec_group_by_vector_query_t,
1524        ivf_rabitq_params: *mut zvec_ivf_rabitq_query_params_t,
1525    ) -> zvec_error_code_t;
1526    pub fn zvec_group_by_vector_query_set_flat_params(
1527        query: *mut zvec_group_by_vector_query_t,
1528        flat_params: *mut zvec_flat_query_params_t,
1529    ) -> zvec_error_code_t;
1530    pub fn zvec_group_by_vector_query_set_vamana_params(
1531        query: *mut zvec_group_by_vector_query_t,
1532        vamana_params: *mut zvec_vamana_query_params_t,
1533    ) -> zvec_error_code_t;
1534    pub fn zvec_group_by_vector_query_set_diskann_params(
1535        query: *mut zvec_group_by_vector_query_t,
1536        diskann_params: *mut zvec_diskann_query_params_t,
1537    ) -> zvec_error_code_t;
1538
1539    // -------------------------------------------------------------------------
1540    // Multi Query / Sub Query
1541    // Functions for creating and configuring multi-queries (hybrid search with
1542    // re-ranking) and their per-field sub-queries.
1543    // -------------------------------------------------------------------------
1544    pub fn zvec_multi_query_create() -> *mut zvec_multi_query_t;
1545    pub fn zvec_multi_query_destroy(query: *mut zvec_multi_query_t);
1546    pub fn zvec_multi_query_add_sub_query(
1547        query: *mut zvec_multi_query_t,
1548        sub_query: *const zvec_sub_query_t,
1549    ) -> zvec_error_code_t;
1550    pub fn zvec_multi_query_get_sub_query_count(query: *const zvec_multi_query_t) -> usize;
1551    pub fn zvec_multi_query_set_topk(
1552        query: *mut zvec_multi_query_t,
1553        topk: c_int,
1554    ) -> zvec_error_code_t;
1555    pub fn zvec_multi_query_get_topk(query: *const zvec_multi_query_t) -> c_int;
1556    pub fn zvec_multi_query_set_filter(
1557        query: *mut zvec_multi_query_t,
1558        filter: *const c_char,
1559    ) -> zvec_error_code_t;
1560    pub fn zvec_multi_query_get_filter(query: *const zvec_multi_query_t) -> *const c_char;
1561    pub fn zvec_multi_query_set_include_vector(
1562        query: *mut zvec_multi_query_t,
1563        include: bool,
1564    ) -> zvec_error_code_t;
1565    pub fn zvec_multi_query_get_include_vector(query: *const zvec_multi_query_t) -> bool;
1566    pub fn zvec_multi_query_set_output_fields(
1567        query: *mut zvec_multi_query_t,
1568        fields: *const *const c_char,
1569        count: usize,
1570    ) -> zvec_error_code_t;
1571    pub fn zvec_multi_query_get_output_fields(
1572        query: *mut zvec_multi_query_t,
1573        fields: *mut *mut *const c_char,
1574        count: *mut usize,
1575    ) -> zvec_error_code_t;
1576    pub fn zvec_multi_query_set_rerank_rrf(
1577        query: *mut zvec_multi_query_t,
1578        rank_constant: c_int,
1579    ) -> zvec_error_code_t;
1580    pub fn zvec_multi_query_set_rerank_weighted(
1581        query: *mut zvec_multi_query_t,
1582        weights: *const f64,
1583        weight_count: usize,
1584    ) -> zvec_error_code_t;
1585
1586    pub fn zvec_sub_query_create() -> *mut zvec_sub_query_t;
1587    pub fn zvec_sub_query_destroy(query: *mut zvec_sub_query_t);
1588    pub fn zvec_sub_query_set_num_candidates(
1589        query: *mut zvec_sub_query_t,
1590        num_candidates: c_int,
1591    ) -> zvec_error_code_t;
1592    pub fn zvec_sub_query_get_num_candidates(query: *const zvec_sub_query_t) -> c_int;
1593    pub fn zvec_sub_query_set_field_name(
1594        query: *mut zvec_sub_query_t,
1595        field_name: *const c_char,
1596    ) -> zvec_error_code_t;
1597    pub fn zvec_sub_query_get_field_name(query: *const zvec_sub_query_t) -> *const c_char;
1598    pub fn zvec_sub_query_set_query_vector(
1599        query: *mut zvec_sub_query_t,
1600        data: *const c_void,
1601        size: usize,
1602    ) -> zvec_error_code_t;
1603    pub fn zvec_sub_query_set_sparse_vector(
1604        query: *mut zvec_sub_query_t,
1605        indices: *const u32,
1606        values: *const f32,
1607        count: usize,
1608    ) -> zvec_error_code_t;
1609    pub fn zvec_sub_query_set_sparse_indices(
1610        query: *mut zvec_sub_query_t,
1611        indices: *const u32,
1612        count: usize,
1613    ) -> zvec_error_code_t;
1614    pub fn zvec_sub_query_set_sparse_values(
1615        query: *mut zvec_sub_query_t,
1616        values: *const f32,
1617        count: usize,
1618    ) -> zvec_error_code_t;
1619    pub fn zvec_sub_query_set_hnsw_params(
1620        query: *mut zvec_sub_query_t,
1621        hnsw_params: *mut zvec_hnsw_query_params_t,
1622    ) -> zvec_error_code_t;
1623    pub fn zvec_sub_query_set_ivf_params(
1624        query: *mut zvec_sub_query_t,
1625        ivf_params: *mut zvec_ivf_query_params_t,
1626    ) -> zvec_error_code_t;
1627    pub fn zvec_sub_query_set_ivf_rabitq_params(
1628        query: *mut zvec_sub_query_t,
1629        ivf_rabitq_params: *mut zvec_ivf_rabitq_query_params_t,
1630    ) -> zvec_error_code_t;
1631    pub fn zvec_sub_query_set_flat_params(
1632        query: *mut zvec_sub_query_t,
1633        flat_params: *mut zvec_flat_query_params_t,
1634    ) -> zvec_error_code_t;
1635    pub fn zvec_sub_query_set_vamana_params(
1636        query: *mut zvec_sub_query_t,
1637        vamana_params: *mut zvec_vamana_query_params_t,
1638    ) -> zvec_error_code_t;
1639    pub fn zvec_sub_query_set_diskann_params(
1640        query: *mut zvec_sub_query_t,
1641        diskann_params: *mut zvec_diskann_query_params_t,
1642    ) -> zvec_error_code_t;
1643    pub fn zvec_sub_query_set_fts_params(
1644        query: *mut zvec_sub_query_t,
1645        fts_params: *mut zvec_fts_query_params_t,
1646    ) -> zvec_error_code_t;
1647    pub fn zvec_sub_query_set_fts(
1648        query: *mut zvec_sub_query_t,
1649        fts: *const zvec_fts_t,
1650    ) -> zvec_error_code_t;
1651
1652    // -------------------------------------------------------------------------
1653    // Document Operations
1654    // Functions for creating, manipulating, and serializing documents.
1655    // -------------------------------------------------------------------------
1656    pub fn zvec_doc_create() -> *mut zvec_doc_t;
1657    pub fn zvec_doc_destroy(doc: *mut zvec_doc_t);
1658    pub fn zvec_doc_clear(doc: *mut zvec_doc_t);
1659    pub fn zvec_doc_add_field_by_value(
1660        doc: *mut zvec_doc_t,
1661        field_name: *const c_char,
1662        data_type: zvec_data_type_t,
1663        value: *const c_void,
1664        value_size: usize,
1665    ) -> zvec_error_code_t;
1666    pub fn zvec_doc_remove_field(
1667        doc: *mut zvec_doc_t,
1668        field_name: *const c_char,
1669    ) -> zvec_error_code_t;
1670    pub fn zvec_docs_free(documents: *mut *mut zvec_doc_t, count: usize);
1671    pub fn zvec_doc_set_pk(doc: *mut zvec_doc_t, pk: *const c_char);
1672    pub fn zvec_doc_set_doc_id(doc: *mut zvec_doc_t, doc_id: u64);
1673    pub fn zvec_doc_set_score(doc: *mut zvec_doc_t, score: f32);
1674    pub fn zvec_doc_set_operator(doc: *mut zvec_doc_t, op: zvec_doc_operator_t);
1675    pub fn zvec_doc_set_field_null(
1676        doc: *mut zvec_doc_t,
1677        field_name: *const c_char,
1678    ) -> zvec_error_code_t;
1679    pub fn zvec_doc_get_doc_id(doc: *const zvec_doc_t) -> u64;
1680    pub fn zvec_doc_get_score(doc: *const zvec_doc_t) -> f32;
1681    pub fn zvec_doc_get_operator(doc: *const zvec_doc_t) -> zvec_doc_operator_t;
1682    pub fn zvec_doc_get_field_count(doc: *const zvec_doc_t) -> usize;
1683    pub fn zvec_doc_get_pk_pointer(doc: *const zvec_doc_t) -> *const c_char;
1684    pub fn zvec_doc_get_pk_copy(doc: *const zvec_doc_t) -> *const c_char;
1685    pub fn zvec_doc_get_field_value_basic(
1686        doc: *const zvec_doc_t,
1687        field_name: *const c_char,
1688        field_type: zvec_data_type_t,
1689        value_buffer: *mut c_void,
1690        buffer_size: usize,
1691    ) -> zvec_error_code_t;
1692    pub fn zvec_doc_get_field_value_copy(
1693        doc: *const zvec_doc_t,
1694        field_name: *const c_char,
1695        field_type: zvec_data_type_t,
1696        value: *mut *mut c_void,
1697        value_size: *mut usize,
1698    ) -> zvec_error_code_t;
1699    pub fn zvec_doc_get_field_value_pointer(
1700        doc: *const zvec_doc_t,
1701        field_name: *const c_char,
1702        field_type: zvec_data_type_t,
1703        value: *mut *const c_void,
1704        value_size: *mut usize,
1705    ) -> zvec_error_code_t;
1706    pub fn zvec_doc_is_empty(doc: *const zvec_doc_t) -> bool;
1707    pub fn zvec_doc_has_field(doc: *const zvec_doc_t, field_name: *const c_char) -> bool;
1708    pub fn zvec_doc_has_field_value(doc: *const zvec_doc_t, field_name: *const c_char) -> bool;
1709    pub fn zvec_doc_is_field_null(doc: *const zvec_doc_t, field_name: *const c_char) -> bool;
1710    pub fn zvec_doc_get_field_names(
1711        doc: *const zvec_doc_t,
1712        field_names: *mut *mut *mut c_char,
1713        count: *mut usize,
1714    ) -> zvec_error_code_t;
1715    pub fn zvec_free_str_array(array: *mut *mut c_char, count: usize);
1716    pub fn zvec_doc_serialize(
1717        doc: *const zvec_doc_t,
1718        data: *mut *mut u8,
1719        size: *mut usize,
1720    ) -> zvec_error_code_t;
1721    pub fn zvec_doc_deserialize(
1722        data: *const u8,
1723        size: usize,
1724        doc: *mut *mut zvec_doc_t,
1725    ) -> zvec_error_code_t;
1726    pub fn zvec_doc_merge(doc: *mut zvec_doc_t, other: *const zvec_doc_t);
1727    pub fn zvec_doc_memory_usage(doc: *const zvec_doc_t) -> usize;
1728    pub fn zvec_doc_validate(
1729        doc: *const zvec_doc_t,
1730        schema: *const zvec_collection_schema_t,
1731        is_update: bool,
1732        error_msg: *mut *mut c_char,
1733    ) -> zvec_error_code_t;
1734    pub fn zvec_doc_to_detail_string(
1735        doc: *const zvec_doc_t,
1736        detail_str: *mut *mut c_char,
1737    ) -> zvec_error_code_t;
1738
1739    // -------------------------------------------------------------------------
1740    // Utility Functions
1741    // Helper functions for converting enums to string representations.
1742    // -------------------------------------------------------------------------
1743    pub fn zvec_data_type_to_string(data_type: zvec_data_type_t) -> *const c_char;
1744    pub fn zvec_index_type_to_string(index_type: zvec_index_type_t) -> *const c_char;
1745    pub fn zvec_metric_type_to_string(metric_type: zvec_metric_type_t) -> *const c_char;
1746}
1747
1748/// Returns the jieba dict directory discovered at build time, if any.
1749///
1750/// The build script looks for the cppjieba dictionary files next to the
1751/// resolved zvec library (prebuilt `data/jieba_dict/`, an SDK install prefix,
1752/// or a zvec source checkout) and records the path here. The high-level
1753/// `zvec` crate uses this to auto-register the default jieba dict dir.
1754pub fn build_time_jieba_dict_dir() -> Option<&'static str> {
1755    option_env!("ZVEC_RUST_JIEBA_DICT_DIR")
1756}