Skip to main content

zova_sys/
lib.rs

1#![allow(non_camel_case_types)]
2#![allow(non_snake_case)]
3#![allow(non_upper_case_globals)]
4
5use std::os::raw::{c_char, c_int, c_void};
6
7/// Raw portable plugin ABI. Lifetimes and limits are defined by zova_plugin.h.
8pub mod plugin;
9
10pub type zova_status = c_int;
11pub type zova_step_result = c_int;
12pub type zova_column_type = c_int;
13pub type zova_sql_value_type = c_int;
14pub type zova_sql_result_type = c_int;
15pub type zova_vector_metric = c_int;
16pub type zova_vector_element_type = c_int;
17pub type zova_graph_target_type = c_int;
18pub type zova_graph_neighbor_direction = c_int;
19pub type zova_object_storage_profile = c_int;
20
21pub const ZOVA_OK: zova_status = 0;
22pub const ZOVA_INVALID_ARGUMENT: zova_status = 1;
23pub const ZOVA_OUT_OF_MEMORY: zova_status = 2;
24pub const ZOVA_BUSY: zova_status = 10;
25pub const ZOVA_LOCKED: zova_status = 11;
26pub const ZOVA_CONSTRAINT: zova_status = 12;
27pub const ZOVA_CANT_OPEN: zova_status = 13;
28pub const ZOVA_READ_ONLY: zova_status = 14;
29pub const ZOVA_CORRUPT: zova_status = 15;
30pub const ZOVA_MISUSE: zova_status = 16;
31pub const ZOVA_SQLITE_ERROR: zova_status = 17;
32pub const ZOVA_INTERRUPTED: zova_status = 18;
33pub const ZOVA_NOT_ZOVA_PATH: zova_status = 30;
34pub const ZOVA_NOT_ZOVA_DATABASE: zova_status = 31;
35pub const ZOVA_UNSUPPORTED_ZOVA_VERSION: zova_status = 32;
36pub const ZOVA_DESTINATION_EXISTS: zova_status = 33;
37pub const ZOVA_ZOVA_NAME_CONFLICT: zova_status = 34;
38pub const ZOVA_MIGRATION_REQUIRED: zova_status = 35;
39pub const ZOVA_UNSUPPORTED_FUTURE_FORMAT: zova_status = 36;
40pub const ZOVA_UNSUPPORTED_LEGACY_FORMAT: zova_status = 37;
41pub const ZOVA_NO_MIGRATION_PATH: zova_status = 38;
42pub const ZOVA_OBJECT_NOT_FOUND: zova_status = 50;
43pub const ZOVA_OBJECT_ALREADY_EXISTS: zova_status = 51;
44pub const ZOVA_OBJECT_CHUNK_NOT_FOUND: zova_status = 52;
45pub const ZOVA_OBJECT_CHUNK_HASH_MISMATCH: zova_status = 53;
46pub const ZOVA_OBJECT_CORRUPT: zova_status = 54;
47pub const ZOVA_OBJECT_MANIFEST_INVALID: zova_status = 55;
48pub const ZOVA_OBJECT_RANGE_INVALID: zova_status = 56;
49pub const ZOVA_OBJECT_TOO_LARGE: zova_status = 57;
50pub const ZOVA_OBJECT_TRANSACTION_ACTIVE: zova_status = 58;
51pub const ZOVA_OBJECT_WRITER_CLOSED: zova_status = 59;
52pub const ZOVA_OBJECT_READER_CLOSED: zova_status = 63;
53pub const ZOVA_BOUND_STORE_EXISTS: zova_status = 60;
54pub const ZOVA_BOUND_STORE_NOT_FOUND: zova_status = 61;
55pub const ZOVA_BOUND_STORE_INVALID: zova_status = 62;
56pub const ZOVA_VECTOR_COLLECTION_EXISTS: zova_status = 70;
57pub const ZOVA_VECTOR_COLLECTION_NOT_FOUND: zova_status = 71;
58pub const ZOVA_VECTOR_NOT_FOUND: zova_status = 72;
59pub const ZOVA_VECTOR_DIMENSION_MISMATCH: zova_status = 73;
60pub const ZOVA_VECTOR_CORRUPT: zova_status = 74;
61pub const ZOVA_VECTOR_INVALID: zova_status = 75;
62pub const ZOVA_GRAPH_EXISTS: zova_status = 80;
63pub const ZOVA_GRAPH_NOT_FOUND: zova_status = 81;
64pub const ZOVA_GRAPH_NODE_NOT_FOUND: zova_status = 82;
65pub const ZOVA_GRAPH_EDGE_NOT_FOUND: zova_status = 83;
66pub const ZOVA_GRAPH_INVALID: zova_status = 84;
67pub const ZOVA_EXTENSION_NOT_FOUND: zova_status = 90;
68pub const ZOVA_EXTENSION_EXISTS: zova_status = 91;
69pub const ZOVA_EXTENSION_INVALID: zova_status = 92;
70pub const ZOVA_EXTENSION_INCOMPATIBLE: zova_status = 93;
71pub const ZOVA_EXTENSION_UNAVAILABLE: zova_status = 94;
72
73pub const ZOVA_STEP_ROW: zova_step_result = 1;
74pub const ZOVA_STEP_DONE: zova_step_result = 2;
75
76pub const ZOVA_COLUMN_INTEGER: zova_column_type = 1;
77pub const ZOVA_COLUMN_FLOAT: zova_column_type = 2;
78pub const ZOVA_COLUMN_TEXT: zova_column_type = 3;
79pub const ZOVA_COLUMN_BLOB: zova_column_type = 4;
80pub const ZOVA_COLUMN_NULL: zova_column_type = 5;
81pub const ZOVA_SQL_VALUE_NULL: zova_sql_value_type = 0;
82pub const ZOVA_SQL_VALUE_INTEGER: zova_sql_value_type = 1;
83pub const ZOVA_SQL_VALUE_FLOAT: zova_sql_value_type = 2;
84pub const ZOVA_SQL_VALUE_TEXT: zova_sql_value_type = 3;
85pub const ZOVA_SQL_VALUE_BLOB: zova_sql_value_type = 4;
86pub const ZOVA_SQL_RESULT_NULL: zova_sql_result_type = 0;
87pub const ZOVA_SQL_RESULT_INTEGER: zova_sql_result_type = 1;
88pub const ZOVA_SQL_RESULT_FLOAT: zova_sql_result_type = 2;
89pub const ZOVA_SQL_RESULT_TEXT: zova_sql_result_type = 3;
90pub const ZOVA_SQL_RESULT_BLOB: zova_sql_result_type = 4;
91pub const ZOVA_SQL_RESULT_ERROR: zova_sql_result_type = 5;
92pub const ZOVA_SQL_FUNCTION_DETERMINISTIC: u32 = 1 << 0;
93pub const ZOVA_SQL_FUNCTION_DIRECT_ONLY: u32 = 1 << 1;
94pub const ZOVA_SQL_FUNCTION_INNOCUOUS: u32 = 1 << 2;
95
96pub const ZOVA_VECTOR_METRIC_COSINE: zova_vector_metric = 0;
97pub const ZOVA_VECTOR_METRIC_L2: zova_vector_metric = 1;
98pub const ZOVA_VECTOR_METRIC_DOT: zova_vector_metric = 2;
99pub const ZOVA_VECTOR_ELEMENT_TYPE_F32: zova_vector_element_type = 0;
100pub const ZOVA_VECTOR_ELEMENT_TYPE_F16: zova_vector_element_type = 1;
101pub const ZOVA_VECTOR_ELEMENT_TYPE_I8: zova_vector_element_type = 2;
102pub const ZOVA_GRAPH_TARGET_NONE: zova_graph_target_type = 0;
103pub const ZOVA_GRAPH_TARGET_RECORD: zova_graph_target_type = 1;
104pub const ZOVA_GRAPH_TARGET_OBJECT: zova_graph_target_type = 2;
105pub const ZOVA_GRAPH_TARGET_OBJECT_CHUNK: zova_graph_target_type = 3;
106pub const ZOVA_GRAPH_TARGET_VECTOR: zova_graph_target_type = 4;
107pub const ZOVA_GRAPH_TARGET_ENTITY: zova_graph_target_type = 5;
108pub const ZOVA_GRAPH_TARGET_FACT: zova_graph_target_type = 6;
109pub const ZOVA_GRAPH_TARGET_CONCEPT: zova_graph_target_type = 7;
110pub const ZOVA_GRAPH_TARGET_EXTERNAL: zova_graph_target_type = 8;
111pub const ZOVA_GRAPH_NEIGHBOR_OUTGOING: zova_graph_neighbor_direction = 0;
112pub const ZOVA_GRAPH_NEIGHBOR_INCOMING: zova_graph_neighbor_direction = 1;
113pub const ZOVA_OBJECT_PROFILE_DEDUPLICATION: zova_object_storage_profile = 0;
114pub const ZOVA_OBJECT_PROFILE_STREAMING: zova_object_storage_profile = 1;
115pub const ZOVA_FRESH_VALUE_NULL: c_int = 0;
116pub const ZOVA_FRESH_VALUE_INT64: c_int = 1;
117pub const ZOVA_FRESH_VALUE_FLOAT64: c_int = 2;
118pub const ZOVA_FRESH_VALUE_TEXT: c_int = 3;
119pub const ZOVA_FRESH_VALUE_BLOB: c_int = 4;
120pub const ZOVA_OPEN_READ_ONLY: u32 = 1 << 0;
121pub const ZOVA_BACKUP_NO_VERIFY: u32 = 1 << 0;
122pub const ZOVA_COMPACT_NO_VERIFY: u32 = 1 << 0;
123pub const ZOVA_RESTORE_NO_VERIFY: u32 = 1 << 0;
124pub const ZOVA_MIGRATE_NO_VERIFY: u32 = 1 << 0;
125
126pub const ZOVA_PROGRESS_COPY: u32 = 0;
127pub const ZOVA_PROGRESS_MIGRATE: u32 = 1;
128pub const ZOVA_PROGRESS_VERIFY: u32 = 2;
129pub const ZOVA_PROGRESS_PUBLISH: u32 = 3;
130pub const ZOVA_PROGRESS_MEMBER_NONE: u32 = 0;
131pub const ZOVA_PROGRESS_MEMBER_MAIN: u32 = 1;
132pub const ZOVA_PROGRESS_MEMBER_OBJECT_STORE: u32 = 2;
133pub const ZOVA_PROGRESS_MEMBER_VECTOR_STORE: u32 = 3;
134pub const ZOVA_PROGRESS_MEMBER_GRAPH_STORE: u32 = 4;
135
136pub const ZOVA_AUTO_VACUUM_NONE: u32 = 0;
137pub const ZOVA_AUTO_VACUUM_FULL: u32 = 1;
138pub const ZOVA_AUTO_VACUUM_INCREMENTAL: u32 = 2;
139
140pub const ZOVA_RECLAIM_MAX_MEMBERS: usize = 4;
141
142pub const ZOVA_FORMAT_CURRENT: c_int = 0;
143pub const ZOVA_FORMAT_MIGRATABLE: c_int = 1;
144pub const ZOVA_FORMAT_UNSUPPORTED_LEGACY: c_int = 2;
145pub const ZOVA_FORMAT_UNSUPPORTED_FUTURE: c_int = 3;
146pub const ZOVA_KV_TOO_LARGE: zova_status = 95;
147pub const ZOVA_KV_CORRUPT: zova_status = 96;
148
149#[repr(C)]
150pub struct zova_database {
151    _private: [u8; 0],
152}
153
154#[repr(C)]
155pub struct zova_statement {
156    _private: [u8; 0],
157}
158
159#[repr(C)]
160pub struct zova_object_writer {
161    _private: [u8; 0],
162}
163
164#[repr(C)]
165pub struct zova_object_reader {
166    _private: [u8; 0],
167}
168
169#[repr(C)]
170pub struct zova_object_seekable_reader {
171    _private: [u8; 0],
172}
173
174#[repr(C)]
175pub struct zova_subscription {
176    _private: [u8; 0],
177}
178
179#[repr(C)]
180pub struct zova_fresh_build {
181    _private: [u8; 0],
182}
183
184#[repr(C)]
185#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
186pub struct zova_object_id {
187    pub bytes: [u8; 32],
188}
189
190#[repr(C)]
191#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
192pub struct zova_object_chunk_id {
193    pub bytes: [u8; 32],
194}
195
196#[repr(C)]
197#[derive(Debug, Copy, Clone)]
198pub struct zova_buffer {
199    pub data: *mut u8,
200    pub len: usize,
201}
202
203#[repr(C)]
204#[derive(Debug, Copy, Clone)]
205pub struct zova_kv_bytes {
206    pub data: *const u8,
207    pub len: usize,
208}
209
210#[repr(C)]
211#[derive(Debug, Copy, Clone)]
212pub struct zova_kv_get_result {
213    pub found: u8,
214    pub value: zova_buffer,
215}
216
217#[repr(C)]
218#[derive(Debug, Copy, Clone)]
219pub struct zova_kv_get_many_results {
220    pub items: *mut zova_kv_get_result,
221    pub len: usize,
222}
223
224#[repr(C)]
225#[derive(Debug, Copy, Clone)]
226pub struct zova_kv_put_entry {
227    pub key: zova_kv_bytes,
228    pub value: zova_kv_bytes,
229}
230
231#[repr(C)]
232#[derive(Debug, Copy, Clone)]
233pub struct zova_kv_get_request {
234    pub db: *mut zova_database,
235    pub ns: zova_kv_bytes,
236    pub key: zova_kv_bytes,
237    pub out_result: *mut zova_kv_get_result,
238}
239
240#[repr(C)]
241#[derive(Debug, Copy, Clone)]
242pub struct zova_kv_get_many_request {
243    pub db: *mut zova_database,
244    pub ns: zova_kv_bytes,
245    pub keys: *const zova_kv_bytes,
246    pub keys_len: usize,
247    pub out_results: *mut zova_kv_get_many_results,
248}
249
250#[repr(C)]
251#[derive(Debug, Copy, Clone)]
252pub struct zova_kv_put_request {
253    pub db: *mut zova_database,
254    pub ns: zova_kv_bytes,
255    pub key: zova_kv_bytes,
256    pub value: zova_kv_bytes,
257}
258
259#[repr(C)]
260#[derive(Debug, Copy, Clone)]
261pub struct zova_kv_put_many_request {
262    pub db: *mut zova_database,
263    pub ns: zova_kv_bytes,
264    pub entries: *const zova_kv_put_entry,
265    pub entries_len: usize,
266}
267
268#[repr(C)]
269#[derive(Debug, Copy, Clone)]
270pub struct zova_kv_delete_request {
271    pub db: *mut zova_database,
272    pub ns: zova_kv_bytes,
273    pub key: zova_kv_bytes,
274}
275
276#[repr(C)]
277#[derive(Debug, Copy, Clone)]
278pub struct zova_kv_delete_many_request {
279    pub db: *mut zova_database,
280    pub ns: zova_kv_bytes,
281    pub keys: *const zova_kv_bytes,
282    pub keys_len: usize,
283}
284
285#[repr(C)]
286#[derive(Debug, Copy, Clone)]
287pub struct zova_kv_count_request {
288    pub db: *mut zova_database,
289    pub ns: zova_kv_bytes,
290    pub out_count: *mut u64,
291}
292
293#[repr(C)]
294#[derive(Debug, Copy, Clone)]
295pub struct zova_kv_clear_namespace_request {
296    pub db: *mut zova_database,
297    pub ns: zova_kv_bytes,
298}
299
300#[repr(C)]
301#[derive(Debug, Copy, Clone)]
302pub struct zova_message {
303    pub data: *mut c_char,
304    pub len: usize,
305}
306
307#[repr(C)]
308#[derive(Debug, Copy, Clone)]
309pub struct zova_text {
310    pub data: *mut c_char,
311    pub len: usize,
312}
313
314#[repr(C)]
315#[derive(Debug, Copy, Clone)]
316pub struct zova_sql_value {
317    pub value_type: zova_sql_value_type,
318    pub int64_value: i64,
319    pub double_value: f64,
320    pub data: *const c_void,
321    pub data_len: usize,
322}
323
324#[repr(C)]
325#[derive(Debug, Copy, Clone)]
326pub struct zova_sql_result {
327    pub result_type: c_int,
328    pub int64_value: i64,
329    pub double_value: f64,
330    pub data: *const c_void,
331    pub data_len: usize,
332    pub error_message: *const c_char,
333    pub error_message_len: usize,
334}
335
336#[repr(C)]
337#[derive(Debug, Copy, Clone)]
338pub struct zova_sql_function_call {
339    pub user_data: *mut c_void,
340    pub argc: usize,
341    pub argv: *const zova_sql_value,
342}
343
344pub type zova_sql_scalar_callback = Option<
345    unsafe extern "C" fn(
346        user_data: *mut c_void,
347        call: *const zova_sql_function_call,
348        out_result: *mut zova_sql_result,
349    ),
350>;
351
352pub type zova_sql_destroy_callback = Option<unsafe extern "C" fn(user_data: *mut c_void)>;
353
354#[repr(C)]
355#[derive(Debug, Copy, Clone)]
356pub struct zova_notification {
357    pub channel: *mut c_char,
358    pub channel_len: usize,
359    pub payload: *mut c_char,
360    pub payload_len: usize,
361    pub sequence: u64,
362    pub dropped_before: u64,
363}
364
365#[repr(C)]
366#[derive(Debug, Copy, Clone)]
367pub struct zova_object_manifest_chunk {
368    pub index: u64,
369    pub hash: zova_object_chunk_id,
370    pub offset: u64,
371    pub size_bytes: u64,
372}
373
374#[repr(C)]
375#[derive(Debug, Copy, Clone)]
376pub struct zova_object_manifest {
377    pub object_id: zova_object_id,
378    pub size_bytes: u64,
379    pub chunk_count: u64,
380    pub chunker: *const c_char,
381    pub chunks: *mut zova_object_manifest_chunk,
382    pub chunks_len: usize,
383}
384
385#[repr(C)]
386#[derive(Debug, Copy, Clone)]
387pub struct zova_vector_collection_options {
388    pub dimensions: u32,
389    pub metric: c_int,
390    pub element_type: c_int,
391}
392
393#[repr(C)]
394#[derive(Debug, Copy, Clone)]
395pub struct zova_vector_values {
396    pub element_type: c_int,
397    pub f32_values: *const f32,
398    pub f16_values: *const u16,
399    pub i8_values: *const i8,
400    pub values_len: usize,
401}
402
403#[repr(C)]
404#[derive(Debug, Copy, Clone)]
405pub struct zova_vector {
406    pub id: *mut c_char,
407    pub id_len: usize,
408    pub element_type: c_int,
409    pub f32_values: *mut f32,
410    pub f16_values: *mut u16,
411    pub i8_values: *mut i8,
412    pub values_len: usize,
413}
414
415#[repr(C)]
416#[derive(Debug, Copy, Clone)]
417pub struct zova_vector_search_result {
418    pub id: *mut c_char,
419    pub id_len: usize,
420    pub distance: f64,
421}
422
423#[repr(C)]
424#[derive(Debug, Copy, Clone)]
425pub struct zova_vector_search_results {
426    pub items: *mut zova_vector_search_result,
427    pub len: usize,
428}
429
430#[repr(C)]
431#[derive(Debug, Copy, Clone)]
432pub struct zova_vector_collection_info {
433    pub name: *mut c_char,
434    pub name_len: usize,
435    pub dimensions: u32,
436    pub metric: c_int,
437    pub element_type: c_int,
438    pub vector_count: u64,
439}
440
441#[repr(C)]
442#[derive(Debug, Copy, Clone)]
443pub struct zova_vector_collection_list {
444    pub items: *mut zova_vector_collection_info,
445    pub len: usize,
446}
447
448#[repr(C)]
449#[derive(Debug, Copy, Clone)]
450pub struct zova_vector_input {
451    pub id: *const c_char,
452    pub values: zova_vector_values,
453}
454
455#[repr(C)]
456#[derive(Debug, Copy, Clone)]
457pub struct zova_graph_info {
458    pub name: *mut c_char,
459    pub name_len: usize,
460    pub node_count: u64,
461    pub edge_count: u64,
462}
463
464#[repr(C)]
465#[derive(Debug, Copy, Clone)]
466pub struct zova_graph_list {
467    pub items: *mut zova_graph_info,
468    pub len: usize,
469}
470
471#[repr(C)]
472#[derive(Debug, Copy, Clone)]
473pub struct zova_extension_info {
474    pub name: *mut c_char,
475    pub name_len: usize,
476    pub version: *mut c_char,
477    pub version_len: usize,
478    pub storage_prefix: *mut c_char,
479    pub storage_prefix_len: usize,
480    pub zova_abi_min: *mut c_char,
481    pub zova_abi_min_len: usize,
482    pub capabilities: *mut c_char,
483    pub capabilities_len: usize,
484    pub required: u8,
485    pub installed_at_unix: i64,
486    pub manifest_json: *mut c_char,
487    pub manifest_json_len: usize,
488}
489
490#[repr(C)]
491#[derive(Debug, Copy, Clone)]
492pub struct zova_extension_list {
493    pub items: *mut zova_extension_info,
494    pub len: usize,
495}
496
497#[repr(C)]
498#[derive(Debug, Copy, Clone)]
499pub struct zova_graph_node {
500    pub graph_name: *mut c_char,
501    pub graph_name_len: usize,
502    pub node_id: *mut c_char,
503    pub node_id_len: usize,
504    pub kind: *mut c_char,
505    pub kind_len: usize,
506    pub target_type: c_int,
507    pub target_namespace: *mut c_char,
508    pub target_namespace_len: usize,
509    pub has_target_namespace: u8,
510    pub target_ref: *mut c_char,
511    pub target_ref_len: usize,
512    pub has_target_ref: u8,
513}
514
515#[repr(C)]
516#[derive(Debug, Copy, Clone)]
517pub struct zova_graph_edge {
518    pub graph_name: *mut c_char,
519    pub graph_name_len: usize,
520    pub from_node_id: *mut c_char,
521    pub from_node_id_len: usize,
522    pub edge_type: *mut c_char,
523    pub edge_type_len: usize,
524    pub to_node_id: *mut c_char,
525    pub to_node_id_len: usize,
526}
527
528#[repr(C)]
529#[derive(Debug, Copy, Clone)]
530pub struct zova_graph_neighbor_result {
531    pub node_id: *mut c_char,
532    pub node_id_len: usize,
533    pub kind: *mut c_char,
534    pub kind_len: usize,
535    pub edge_type: *mut c_char,
536    pub edge_type_len: usize,
537}
538
539#[repr(C)]
540#[derive(Debug, Copy, Clone)]
541pub struct zova_graph_neighbor_results {
542    pub items: *mut zova_graph_neighbor_result,
543    pub len: usize,
544}
545
546#[repr(C)]
547#[derive(Debug, Copy, Clone)]
548pub struct zova_graph_keyed_neighbor_result {
549    pub edge_key: i64,
550    pub neighbor_node_key: i64,
551    pub node_id: *mut c_char,
552    pub node_id_len: usize,
553    pub kind: *mut c_char,
554    pub kind_len: usize,
555    pub edge_type: *mut c_char,
556    pub edge_type_len: usize,
557}
558
559#[repr(C)]
560#[derive(Debug, Copy, Clone)]
561pub struct zova_graph_keyed_neighbor_results {
562    pub items: *mut zova_graph_keyed_neighbor_result,
563    pub len: usize,
564}
565
566#[repr(C)]
567pub struct zova_graph_keyed_node_result {
568    pub found: u8,
569    pub node_key: i64,
570    pub node_id: *mut c_char,
571    pub node_id_len: usize,
572    pub kind: *mut c_char,
573    pub kind_len: usize,
574    pub created_order: i64,
575}
576#[repr(C)]
577pub struct zova_graph_keyed_node_results {
578    pub items: *mut zova_graph_keyed_node_result,
579    pub len: usize,
580}
581#[repr(C)]
582pub struct zova_graph_keyed_edge_result {
583    pub found: u8,
584    pub edge_key: i64,
585    pub source_node_key: i64,
586    pub edge_type: *mut c_char,
587    pub edge_type_len: usize,
588    pub target_node_key: i64,
589    pub created_order: i64,
590}
591#[repr(C)]
592pub struct zova_graph_keyed_edge_results {
593    pub items: *mut zova_graph_keyed_edge_result,
594    pub len: usize,
595}
596
597#[repr(C)]
598pub struct zova_graph_edge_payload_result {
599    pub found: u8,
600    pub edge_key: i64,
601    pub payload: *mut u8,
602    pub payload_len: usize,
603}
604#[repr(C)]
605pub struct zova_graph_edge_payload_results {
606    pub items: *mut zova_graph_edge_payload_result,
607    pub len: usize,
608}
609
610#[repr(C)]
611#[derive(Debug, Copy, Clone, Default)]
612pub struct zova_fresh_build_profile {
613    pub validation_ms: f64,
614    pub table_load_ms: f64,
615    pub fts_load_ms: f64,
616    pub graph_load_ms: f64,
617    pub graph_validation_ms: f64,
618    pub graph_key_generation_ms: f64,
619    pub graph_node_load_ms: f64,
620    pub graph_edge_load_ms: f64,
621    pub vector_load_ms: f64,
622    pub index_build_ms: f64,
623    pub commit_ms: f64,
624    pub table_rows: u64,
625    pub fts_rows: u64,
626    pub vector_rows: u64,
627    pub payload_bytes: u64,
628}
629
630#[repr(C)]
631pub struct zova_fresh_value {
632    pub value_type: c_int,
633    pub int64_value: i64,
634    pub float64_value: f64,
635    pub bytes: *const u8,
636    pub bytes_len: usize,
637}
638
639#[repr(C)]
640#[derive(Debug, Copy, Clone)]
641pub struct zova_graph_scan_cursor {
642    pub created_order: i64,
643    pub key: i64,
644}
645
646#[repr(C)]
647#[derive(Debug, Copy, Clone)]
648pub struct zova_graph_scan_node {
649    pub node_key: i64,
650    pub node_id: *mut c_char,
651    pub node_id_len: usize,
652    pub kind: *mut c_char,
653    pub kind_len: usize,
654    pub created_order: i64,
655}
656
657#[repr(C)]
658#[derive(Debug, Copy, Clone)]
659pub struct zova_graph_scan_edge {
660    pub edge_key: i64,
661    pub source_node_key: i64,
662    pub edge_type: *mut c_char,
663    pub edge_type_len: usize,
664    pub target_node_key: i64,
665    pub created_order: i64,
666}
667
668#[repr(C)]
669#[derive(Debug, Copy, Clone)]
670pub struct zova_graph_scan_results {
671    pub nodes: *mut zova_graph_scan_node,
672    pub nodes_len: usize,
673    pub edges: *mut zova_graph_scan_edge,
674    pub edges_len: usize,
675    pub has_more_nodes: u8,
676    pub has_more_edges: u8,
677}
678
679#[repr(C)]
680#[derive(Debug, Copy, Clone)]
681pub struct zova_graph_walk_result {
682    pub node_id: *mut c_char,
683    pub node_id_len: usize,
684    pub kind: *mut c_char,
685    pub kind_len: usize,
686    pub depth: u32,
687    pub predecessor_node_id: *mut c_char,
688    pub predecessor_node_id_len: usize,
689    pub has_predecessor_node_id: u8,
690    pub edge_type: *mut c_char,
691    pub edge_type_len: usize,
692    pub has_edge_type: u8,
693}
694
695#[repr(C)]
696#[derive(Debug, Copy, Clone)]
697pub struct zova_graph_walk_results {
698    pub items: *mut zova_graph_walk_result,
699    pub len: usize,
700}
701
702#[repr(C)]
703pub struct zova_database_open_request {
704    pub path: *const c_char,
705    pub out_db: *mut *mut zova_database,
706    pub out_error_message: *mut zova_message,
707}
708
709#[repr(C)]
710pub struct zova_database_create_memory_request {
711    pub out_db: *mut *mut zova_database,
712    pub out_error_message: *mut zova_message,
713}
714
715#[repr(C)]
716pub struct zova_database_restore_to_memory_request {
717    pub source_path: *const c_char,
718    pub flags: u32,
719    pub out_db: *mut *mut zova_database,
720    pub out_error_message: *mut zova_message,
721}
722
723#[repr(C)]
724pub struct zova_database_create_options_request {
725    pub path: *const c_char,
726    pub page_size: u32,
727    pub out_db: *mut *mut zova_database,
728    pub out_error_message: *mut zova_message,
729}
730
731#[repr(C)]
732pub struct zova_database_open_options_request {
733    pub path: *const c_char,
734    pub flags: u32,
735    pub busy_timeout_ms: u32,
736    pub out_db: *mut *mut zova_database,
737    pub out_error_message: *mut zova_message,
738}
739
740#[repr(C)]
741pub struct zova_database_open_extensions_request {
742    pub path: *const c_char,
743    pub flags: u32,
744    pub busy_timeout_ms: u32,
745    pub extension_bundle_paths: *const *const c_char,
746    pub extension_bundle_count: usize,
747    pub trust_store_path: *const c_char,
748    pub out_db: *mut *mut zova_database,
749    pub out_error_message: *mut zova_message,
750}
751
752#[repr(C)]
753pub struct zova_database_open_plugins_request {
754    pub path: *const c_char,
755    pub flags: u32,
756    pub busy_timeout_ms: u32,
757    pub extension_bundle_paths: *const *const c_char,
758    pub extension_bundle_count: usize,
759    pub trust_store_path: *const c_char,
760    pub plugins: *const *const plugin::zova_plugin_descriptor_v1,
761    pub plugin_count: usize,
762    pub out_db: *mut *mut zova_database,
763    pub out_error_message: *mut zova_message,
764}
765
766#[repr(C)]
767pub struct zova_extension_bundle_request {
768    pub bundle_path: *const c_char,
769    pub trust_store_path: *const c_char,
770    pub out_error_message: *mut zova_message,
771}
772
773#[repr(C)]
774pub struct zova_extension_bundle_untrust_request {
775    pub identifier: *const c_char,
776    pub trust_store_path: *const c_char,
777    pub out_removed: *mut u8,
778    pub out_error_message: *mut zova_message,
779}
780
781#[repr(C)]
782pub struct zova_convert_sqlite_to_zova_request {
783    pub source_path: *const c_char,
784    pub dest_path: *const c_char,
785    pub out_error_message: *mut zova_message,
786}
787
788#[repr(C)]
789pub struct zova_database_backup_request {
790    pub db: *mut zova_database,
791    pub destination_path: *const c_char,
792    pub flags: u32,
793}
794
795#[repr(C)]
796pub struct zova_database_compact_request {
797    pub db: *mut zova_database,
798    pub destination_path: *const c_char,
799    pub flags: u32,
800}
801
802#[repr(C)]
803#[derive(Clone, Copy, Debug)]
804pub struct zova_progress {
805    pub phase: u32,
806    pub member: u32,
807    pub done: u64,
808    pub total: u64,
809}
810
811/// Returns non-zero to cancel the operation.
812pub type zova_progress_fn =
813    Option<unsafe extern "C" fn(user_data: *mut c_void, progress: *const zova_progress) -> i32>;
814
815#[repr(C)]
816pub struct zova_database_backup_progress_request {
817    pub db: *mut zova_database,
818    pub destination_path: *const c_char,
819    pub flags: u32,
820    pub progress: zova_progress_fn,
821    pub progress_user_data: *mut c_void,
822}
823
824#[repr(C)]
825pub struct zova_database_compact_progress_request {
826    pub db: *mut zova_database,
827    pub destination_path: *const c_char,
828    pub flags: u32,
829    pub progress: zova_progress_fn,
830    pub progress_user_data: *mut c_void,
831}
832
833#[repr(C)]
834#[derive(Clone, Copy, Debug, Default)]
835pub struct zova_reclaimed_member {
836    pub member: u32,
837    pub auto_vacuum: u32,
838    pub page_size: u32,
839    pub pages_released: u64,
840    pub free_pages_left: u64,
841}
842
843#[repr(C)]
844#[derive(Clone, Copy, Debug, Default)]
845pub struct zova_reclaim_result {
846    pub member_count: usize,
847    pub members: [zova_reclaimed_member; ZOVA_RECLAIM_MAX_MEMBERS],
848}
849
850#[repr(C)]
851pub struct zova_database_reclaim_request {
852    pub db: *mut zova_database,
853    pub max_pages: u64,
854    pub step_pages: u32,
855    pub out_result: *mut zova_reclaim_result,
856}
857
858#[repr(C)]
859pub struct zova_database_restore_request {
860    pub source_path: *const c_char,
861    pub destination_path: *const c_char,
862    pub flags: u32,
863    pub out_error_message: *mut zova_message,
864}
865
866#[repr(C)]
867pub struct zova_database_format_info {
868    pub format_version: u32,
869    pub compatibility: c_int,
870}
871
872#[repr(C)]
873pub struct zova_database_probe_format_request {
874    pub path: *const c_char,
875    pub out_info: *mut zova_database_format_info,
876    pub out_error_message: *mut zova_message,
877}
878
879#[repr(C)]
880pub struct zova_database_migrate_request {
881    pub source_path: *const c_char,
882    pub destination_path: *const c_char,
883    pub flags: u32,
884    pub out_error_message: *mut zova_message,
885}
886
887#[repr(C)]
888pub struct zova_database_migrate_extensions_request {
889    pub source_path: *const c_char,
890    pub destination_path: *const c_char,
891    pub flags: u32,
892    pub extension_bundle_paths: *const *const c_char,
893    pub extension_bundle_count: usize,
894    pub trust_store_path: *const c_char,
895    pub plugins: *const *const plugin::zova_plugin_descriptor_v1,
896    pub plugin_count: usize,
897    pub out_error_message: *mut zova_message,
898}
899
900#[repr(C)]
901pub struct zova_database_migrate_progress_request {
902    pub source_path: *const c_char,
903    pub destination_path: *const c_char,
904    pub flags: u32,
905    pub extension_bundle_paths: *const *const c_char,
906    pub extension_bundle_count: usize,
907    pub trust_store_path: *const c_char,
908    pub plugins: *const *const plugin::zova_plugin_descriptor_v1,
909    pub plugin_count: usize,
910    pub progress: zova_progress_fn,
911    pub progress_user_data: *mut c_void,
912    pub out_error_message: *mut zova_message,
913}
914
915#[repr(C)]
916pub struct zova_database_exec_request {
917    pub db: *mut zova_database,
918    pub sql: *const c_char,
919}
920
921#[repr(C)]
922pub struct zova_sql_function_register_request {
923    pub db: *mut zova_database,
924    pub name: *const c_char,
925    pub arity: c_int,
926    pub flags: u32,
927    pub user_data: *mut c_void,
928    pub callback: zova_sql_scalar_callback,
929    pub destroy: zova_sql_destroy_callback,
930}
931
932#[repr(C)]
933pub struct zova_database_simple_request {
934    pub db: *mut zova_database,
935}
936
937#[repr(C)]
938pub struct zova_database_savepoint_request {
939    pub db: *mut zova_database,
940    pub name: *const c_char,
941}
942
943#[repr(C)]
944pub struct zova_database_busy_timeout_request {
945    pub db: *mut zova_database,
946    pub milliseconds: u32,
947}
948
949#[repr(C)]
950pub struct zova_database_last_insert_rowid_request {
951    pub db: *mut zova_database,
952    pub out_rowid: *mut i64,
953}
954
955#[repr(C)]
956pub struct zova_database_changes_request {
957    pub db: *mut zova_database,
958    pub out_changes: *mut i64,
959}
960
961#[repr(C)]
962pub struct zova_database_total_changes_request {
963    pub db: *mut zova_database,
964    pub out_total_changes: *mut i64,
965}
966
967#[repr(C)]
968pub struct zova_database_notify_request {
969    pub db: *mut zova_database,
970    pub channel: *const c_char,
971    pub payload: *const u8,
972    pub payload_len: usize,
973}
974
975#[repr(C)]
976pub struct zova_database_listen_request {
977    pub db: *mut zova_database,
978    pub channel: *const c_char,
979    pub out_subscription: *mut *mut zova_subscription,
980}
981
982#[repr(C)]
983pub struct zova_subscription_try_receive_request {
984    pub subscription: *mut zova_subscription,
985    pub out_notification: *mut zova_notification,
986    pub out_has_notification: *mut u8,
987}
988
989#[repr(C)]
990pub struct zova_database_prepare_request {
991    pub db: *mut zova_database,
992    pub sql: *const c_char,
993    pub out_statement: *mut *mut zova_statement,
994}
995
996#[repr(C)]
997pub struct zova_statement_step_request {
998    pub statement: *mut zova_statement,
999    pub out_result: *mut zova_step_result,
1000}
1001
1002#[repr(C)]
1003pub struct zova_statement_bind_null_request {
1004    pub statement: *mut zova_statement,
1005    pub index: c_int,
1006}
1007
1008#[repr(C)]
1009pub struct zova_statement_bind_int64_request {
1010    pub statement: *mut zova_statement,
1011    pub index: c_int,
1012    pub value: i64,
1013}
1014
1015#[repr(C)]
1016pub struct zova_statement_bind_double_request {
1017    pub statement: *mut zova_statement,
1018    pub index: c_int,
1019    pub value: f64,
1020}
1021
1022#[repr(C)]
1023pub struct zova_statement_bind_text_request {
1024    pub statement: *mut zova_statement,
1025    pub index: c_int,
1026    pub data: *const u8,
1027    pub len: usize,
1028}
1029
1030#[repr(C)]
1031pub struct zova_statement_bind_blob_request {
1032    pub statement: *mut zova_statement,
1033    pub index: c_int,
1034    pub data: *const u8,
1035    pub len: usize,
1036}
1037
1038#[repr(C)]
1039pub struct zova_statement_parameter_count_request {
1040    pub statement: *mut zova_statement,
1041    pub out_count: *mut c_int,
1042}
1043
1044#[repr(C)]
1045pub struct zova_statement_parameter_index_request {
1046    pub statement: *mut zova_statement,
1047    pub name: *const c_char,
1048    pub out_index: *mut c_int,
1049}
1050
1051#[repr(C)]
1052pub struct zova_statement_column_count_request {
1053    pub statement: *mut zova_statement,
1054    pub out_count: *mut c_int,
1055}
1056
1057#[repr(C)]
1058pub struct zova_statement_column_name_request {
1059    pub statement: *mut zova_statement,
1060    pub index: c_int,
1061    pub out_name: *mut zova_text,
1062}
1063
1064#[repr(C)]
1065pub struct zova_statement_column_type_request {
1066    pub statement: *mut zova_statement,
1067    pub index: c_int,
1068    pub out_type: *mut zova_column_type,
1069}
1070
1071#[repr(C)]
1072pub struct zova_statement_column_int64_request {
1073    pub statement: *mut zova_statement,
1074    pub index: c_int,
1075    pub out_value: *mut i64,
1076}
1077
1078#[repr(C)]
1079pub struct zova_statement_column_double_request {
1080    pub statement: *mut zova_statement,
1081    pub index: c_int,
1082    pub out_value: *mut f64,
1083}
1084
1085#[repr(C)]
1086pub struct zova_statement_column_text_request {
1087    pub statement: *mut zova_statement,
1088    pub index: c_int,
1089    pub out_text: *mut zova_text,
1090}
1091
1092#[repr(C)]
1093pub struct zova_statement_column_blob_request {
1094    pub statement: *mut zova_statement,
1095    pub index: c_int,
1096    pub out_buffer: *mut zova_buffer,
1097}
1098
1099#[repr(C)]
1100pub struct zova_object_put_request {
1101    pub db: *mut zova_database,
1102    pub data: *const u8,
1103    pub len: usize,
1104    pub out_id: *mut zova_object_id,
1105}
1106
1107#[repr(C)]
1108#[derive(Debug, Copy, Clone)]
1109pub struct zova_object_put_options {
1110    pub profile: c_int,
1111}
1112
1113#[repr(C)]
1114#[derive(Debug, Copy, Clone)]
1115pub struct zova_object_put_with_options_request {
1116    pub db: *mut zova_database,
1117    pub data: *const u8,
1118    pub len: usize,
1119    pub options: zova_object_put_options,
1120    pub out_id: *mut zova_object_id,
1121}
1122
1123#[repr(C)]
1124pub struct zova_object_get_request {
1125    pub db: *mut zova_database,
1126    pub id: zova_object_id,
1127    pub out_buffer: *mut zova_buffer,
1128}
1129
1130#[repr(C)]
1131pub struct zova_object_read_range_request {
1132    pub db: *mut zova_database,
1133    pub id: zova_object_id,
1134    pub offset: u64,
1135    pub buffer: *mut u8,
1136    pub buffer_len: usize,
1137    pub out_copied: *mut usize,
1138}
1139
1140#[repr(C)]
1141pub struct zova_object_exists_request {
1142    pub db: *mut zova_database,
1143    pub id: zova_object_id,
1144    pub out_exists: *mut u8,
1145}
1146
1147#[repr(C)]
1148pub struct zova_object_size_request {
1149    pub db: *mut zova_database,
1150    pub id: zova_object_id,
1151    pub out_size: *mut u64,
1152}
1153
1154#[repr(C)]
1155pub struct zova_object_chunk_count_request {
1156    pub db: *mut zova_database,
1157    pub id: zova_object_id,
1158    pub out_count: *mut u64,
1159}
1160
1161#[repr(C)]
1162pub struct zova_object_delete_request {
1163    pub db: *mut zova_database,
1164    pub id: zova_object_id,
1165}
1166
1167#[repr(C)]
1168pub struct zova_object_manifest_get_request {
1169    pub db: *mut zova_database,
1170    pub id: zova_object_id,
1171    pub out_manifest: *mut zova_object_manifest,
1172}
1173
1174#[repr(C)]
1175pub struct zova_object_chunk_get_request {
1176    pub db: *mut zova_database,
1177    pub hash: zova_object_chunk_id,
1178    pub out_buffer: *mut zova_buffer,
1179}
1180
1181#[repr(C)]
1182pub struct zova_object_chunk_put_request {
1183    pub db: *mut zova_database,
1184    pub expected_hash: zova_object_chunk_id,
1185    pub data: *const u8,
1186    pub len: usize,
1187}
1188
1189#[repr(C)]
1190#[derive(Debug, Copy, Clone)]
1191pub struct zova_object_chunk_put_with_options_request {
1192    pub db: *mut zova_database,
1193    pub expected_hash: zova_object_chunk_id,
1194    pub data: *const u8,
1195    pub len: usize,
1196    pub options: zova_object_put_options,
1197}
1198
1199#[repr(C)]
1200pub struct zova_object_chunk_delete_request {
1201    pub db: *mut zova_database,
1202    pub hash: zova_object_chunk_id,
1203    pub out_deleted: *mut u8,
1204}
1205
1206#[repr(C)]
1207pub struct zova_object_assemble_from_chunks_request {
1208    pub db: *mut zova_database,
1209    pub id: zova_object_id,
1210    pub size_bytes: u64,
1211    pub chunks: *const zova_object_manifest_chunk,
1212    pub chunk_count: usize,
1213}
1214
1215#[repr(C)]
1216#[derive(Debug, Copy, Clone)]
1217pub struct zova_object_assemble_from_chunks_with_options_request {
1218    pub db: *mut zova_database,
1219    pub id: zova_object_id,
1220    pub size_bytes: u64,
1221    pub chunks: *const zova_object_manifest_chunk,
1222    pub chunk_count: usize,
1223    pub options: zova_object_put_options,
1224}
1225
1226#[repr(C)]
1227pub struct zova_object_writer_create_request {
1228    pub db: *mut zova_database,
1229    pub out_writer: *mut *mut zova_object_writer,
1230}
1231
1232#[repr(C)]
1233#[derive(Debug, Copy, Clone)]
1234pub struct zova_object_writer_create_with_options_request {
1235    pub db: *mut zova_database,
1236    pub options: zova_object_put_options,
1237    pub out_writer: *mut *mut zova_object_writer,
1238}
1239
1240#[repr(C)]
1241pub struct zova_object_writer_write_request {
1242    pub writer: *mut zova_object_writer,
1243    pub data: *const u8,
1244    pub len: usize,
1245}
1246
1247#[repr(C)]
1248pub struct zova_object_writer_finish_request {
1249    pub writer: *mut zova_object_writer,
1250    pub out_id: *mut zova_object_id,
1251}
1252
1253#[repr(C)]
1254pub struct zova_object_writer_cancel_request {
1255    pub writer: *mut zova_object_writer,
1256}
1257
1258#[repr(C)]
1259#[derive(Debug, Copy, Clone)]
1260pub struct zova_object_reader_create_request {
1261    pub db: *mut zova_database,
1262    pub id: zova_object_id,
1263    pub out_reader: *mut *mut zova_object_reader,
1264}
1265
1266#[repr(C)]
1267#[derive(Debug, Copy, Clone)]
1268pub struct zova_object_reader_read_request {
1269    pub reader: *mut zova_object_reader,
1270    pub buffer: *mut u8,
1271    pub buffer_len: usize,
1272    pub out_read: *mut usize,
1273}
1274
1275#[repr(C)]
1276#[derive(Debug, Copy, Clone)]
1277pub struct zova_object_reader_destroy_request {
1278    pub reader: *mut *mut zova_object_reader,
1279}
1280
1281#[repr(C)]
1282#[derive(Debug, Copy, Clone)]
1283pub struct zova_object_seekable_reader_create_request {
1284    pub db: *mut zova_database,
1285    pub id: zova_object_id,
1286    pub out_reader: *mut *mut zova_object_seekable_reader,
1287    pub out_size: *mut u64,
1288}
1289
1290#[repr(C)]
1291#[derive(Debug, Copy, Clone)]
1292pub struct zova_object_seekable_reader_read_request {
1293    pub reader: *mut zova_object_seekable_reader,
1294    pub buffer: *mut u8,
1295    pub buffer_len: usize,
1296    pub out_read: *mut usize,
1297}
1298
1299#[repr(C)]
1300#[derive(Debug, Copy, Clone)]
1301pub struct zova_object_seekable_reader_seek_request {
1302    pub reader: *mut zova_object_seekable_reader,
1303    pub offset: u64,
1304}
1305
1306#[repr(C)]
1307#[derive(Debug, Copy, Clone)]
1308pub struct zova_object_seekable_reader_destroy_request {
1309    pub reader: *mut *mut zova_object_seekable_reader,
1310}
1311
1312#[repr(C)]
1313pub struct zova_vector_collection_create_request {
1314    pub db: *mut zova_database,
1315    pub name: *const c_char,
1316    pub options: zova_vector_collection_options,
1317}
1318
1319#[repr(C)]
1320pub struct zova_vector_collection_exists_request {
1321    pub db: *mut zova_database,
1322    pub name: *const c_char,
1323    pub out_exists: *mut u8,
1324}
1325
1326#[repr(C)]
1327pub struct zova_vector_put_request {
1328    pub db: *mut zova_database,
1329    pub collection_name: *const c_char,
1330    pub vector_id: *const c_char,
1331    pub values: zova_vector_values,
1332}
1333
1334#[repr(C)]
1335pub struct zova_vector_get_request {
1336    pub db: *mut zova_database,
1337    pub collection_name: *const c_char,
1338    pub vector_id: *const c_char,
1339    pub out_vector: *mut zova_vector,
1340}
1341
1342#[repr(C)]
1343pub struct zova_vector_exists_request {
1344    pub db: *mut zova_database,
1345    pub collection_name: *const c_char,
1346    pub vector_id: *const c_char,
1347    pub out_exists: *mut u8,
1348}
1349
1350#[repr(C)]
1351pub struct zova_vector_delete_request {
1352    pub db: *mut zova_database,
1353    pub collection_name: *const c_char,
1354    pub vector_id: *const c_char,
1355}
1356
1357#[repr(C)]
1358pub struct zova_vector_search_request {
1359    pub db: *mut zova_database,
1360    pub collection_name: *const c_char,
1361    pub query: zova_vector_values,
1362    pub limit: usize,
1363    pub out_results: *mut zova_vector_search_results,
1364}
1365
1366#[repr(C)]
1367pub struct zova_vector_search_in_request {
1368    pub db: *mut zova_database,
1369    pub collection_name: *const c_char,
1370    pub query: zova_vector_values,
1371    pub candidate_ids: *const *const c_char,
1372    pub candidate_count: usize,
1373    pub limit: usize,
1374    pub out_results: *mut zova_vector_search_results,
1375}
1376
1377#[repr(C)]
1378pub struct zova_vector_collection_info_get_request {
1379    pub db: *mut zova_database,
1380    pub name: *const c_char,
1381    pub out_info: *mut zova_vector_collection_info,
1382}
1383
1384#[repr(C)]
1385pub struct zova_vector_collections_list_request {
1386    pub db: *mut zova_database,
1387    pub out_list: *mut zova_vector_collection_list,
1388}
1389
1390#[repr(C)]
1391pub struct zova_vector_put_many_request {
1392    pub db: *mut zova_database,
1393    pub collection_name: *const c_char,
1394    pub vectors: *const zova_vector_input,
1395    pub vectors_len: usize,
1396}
1397
1398#[repr(C)]
1399pub struct zova_vector_delete_many_request {
1400    pub db: *mut zova_database,
1401    pub collection_name: *const c_char,
1402    pub vector_ids: *const *const c_char,
1403    pub vector_count: usize,
1404}
1405
1406#[repr(C)]
1407pub struct zova_vector_collection_delete_request {
1408    pub db: *mut zova_database,
1409    pub name: *const c_char,
1410}
1411
1412#[repr(C)]
1413pub struct zova_vector_search_within_request {
1414    pub db: *mut zova_database,
1415    pub collection_name: *const c_char,
1416    pub query: zova_vector_values,
1417    pub max_distance: f64,
1418    pub limit: usize,
1419    pub out_results: *mut zova_vector_search_results,
1420}
1421
1422#[repr(C)]
1423pub struct zova_vector_search_in_within_request {
1424    pub db: *mut zova_database,
1425    pub collection_name: *const c_char,
1426    pub query: zova_vector_values,
1427    pub candidate_ids: *const *const c_char,
1428    pub candidate_count: usize,
1429    pub max_distance: f64,
1430    pub limit: usize,
1431    pub out_results: *mut zova_vector_search_results,
1432}
1433
1434#[repr(C)]
1435pub struct zova_vector_search_by_id_request {
1436    pub db: *mut zova_database,
1437    pub collection_name: *const c_char,
1438    pub source_vector_id: *const c_char,
1439    pub limit: usize,
1440    pub out_results: *mut zova_vector_search_results,
1441}
1442
1443#[repr(C)]
1444pub struct zova_vector_search_by_id_in_request {
1445    pub db: *mut zova_database,
1446    pub collection_name: *const c_char,
1447    pub source_vector_id: *const c_char,
1448    pub candidate_ids: *const *const c_char,
1449    pub candidate_count: usize,
1450    pub limit: usize,
1451    pub out_results: *mut zova_vector_search_results,
1452}
1453
1454#[repr(C)]
1455pub struct zova_vector_search_by_id_within_request {
1456    pub db: *mut zova_database,
1457    pub collection_name: *const c_char,
1458    pub source_vector_id: *const c_char,
1459    pub max_distance: f64,
1460    pub limit: usize,
1461    pub out_results: *mut zova_vector_search_results,
1462}
1463
1464#[repr(C)]
1465pub struct zova_vector_search_by_id_in_within_request {
1466    pub db: *mut zova_database,
1467    pub collection_name: *const c_char,
1468    pub source_vector_id: *const c_char,
1469    pub candidate_ids: *const *const c_char,
1470    pub candidate_count: usize,
1471    pub max_distance: f64,
1472    pub limit: usize,
1473    pub out_results: *mut zova_vector_search_results,
1474}
1475
1476#[repr(C)]
1477pub struct zova_graph_create_request {
1478    pub db: *mut zova_database,
1479    pub name: *const c_char,
1480}
1481
1482#[repr(C)]
1483pub struct zova_graph_exists_request {
1484    pub db: *mut zova_database,
1485    pub name: *const c_char,
1486    pub out_exists: *mut u8,
1487}
1488
1489#[repr(C)]
1490pub struct zova_graph_info_get_request {
1491    pub db: *mut zova_database,
1492    pub name: *const c_char,
1493    pub out_info: *mut zova_graph_info,
1494}
1495
1496#[repr(C)]
1497pub struct zova_graph_list_request {
1498    pub db: *mut zova_database,
1499    pub out_list: *mut zova_graph_list,
1500}
1501
1502#[repr(C)]
1503pub struct zova_database_extension_request {
1504    pub db: *mut zova_database,
1505    pub name: *const c_char,
1506}
1507
1508#[repr(C)]
1509pub struct zova_database_extension_info_request {
1510    pub db: *mut zova_database,
1511    pub name: *const c_char,
1512    pub out_info: *mut zova_extension_info,
1513}
1514
1515#[repr(C)]
1516pub struct zova_database_extension_list_request {
1517    pub db: *mut zova_database,
1518    pub out_list: *mut zova_extension_list,
1519}
1520
1521#[repr(C)]
1522pub struct zova_graph_delete_request {
1523    pub db: *mut zova_database,
1524    pub name: *const c_char,
1525}
1526
1527#[repr(C)]
1528pub struct zova_graph_node_put_request {
1529    pub db: *mut zova_database,
1530    pub graph_name: *const c_char,
1531    pub node_id: *const c_char,
1532    pub kind: *const c_char,
1533    pub target_type: c_int,
1534    pub target_namespace: *const c_char,
1535    pub target_ref: *const c_char,
1536}
1537
1538#[repr(C)]
1539pub struct zova_graph_node_input {
1540    pub graph_name: *const c_char,
1541    pub node_id: *const c_char,
1542    pub kind: *const c_char,
1543    pub target_type: c_int,
1544    pub target_namespace: *const c_char,
1545    pub target_ref: *const c_char,
1546}
1547
1548#[repr(C)]
1549pub struct zova_graph_node_put_many_request {
1550    pub db: *mut zova_database,
1551    pub nodes: *const zova_graph_node_input,
1552    pub nodes_len: usize,
1553}
1554
1555#[repr(C)]
1556pub struct zova_graph_node_put_many_keyed_request {
1557    pub db: *mut zova_database,
1558    pub nodes: *const zova_graph_node_input,
1559    pub nodes_len: usize,
1560    pub out_node_keys: *mut i64,
1561    pub out_node_keys_capacity: usize,
1562}
1563
1564#[repr(C)]
1565pub struct zova_graph_fresh_node_input {
1566    pub node_id: *const c_char,
1567    pub kind: *const c_char,
1568    pub target_type: c_int,
1569    pub target_namespace: *const c_char,
1570    pub target_ref: *const c_char,
1571}
1572
1573#[repr(C)]
1574pub struct zova_graph_fresh_edge_input {
1575    pub from_node_ordinal: usize,
1576    pub edge_type: *const c_char,
1577    pub to_node_ordinal: usize,
1578}
1579
1580#[repr(C)]
1581pub struct zova_graph_fresh_edge_payload_input {
1582    pub from_node_ordinal: usize,
1583    pub edge_type: *const c_char,
1584    pub to_node_ordinal: usize,
1585    pub payload: *const u8,
1586    pub payload_len: usize,
1587}
1588
1589#[repr(C)]
1590pub struct zova_graph_build_fresh_keyed_request {
1591    pub db: *mut zova_database,
1592    pub graph_name: *const c_char,
1593    pub nodes: *const zova_graph_fresh_node_input,
1594    pub nodes_len: usize,
1595    pub edges: *const zova_graph_fresh_edge_input,
1596    pub edges_len: usize,
1597    pub out_node_keys: *mut i64,
1598    pub out_node_keys_capacity: usize,
1599    pub out_edge_keys: *mut i64,
1600    pub out_edge_keys_capacity: usize,
1601}
1602
1603#[repr(C)]
1604pub struct zova_graph_build_fresh_prepared_keyed_with_payloads_request {
1605    pub db: *mut zova_database,
1606    pub graph_name: *const c_char,
1607    pub nodes: *const zova_graph_fresh_node_input,
1608    pub nodes_len: usize,
1609    pub edges: *const zova_graph_fresh_edge_payload_input,
1610    pub edges_len: usize,
1611    /// Optional immediate output. Keys are invalid if the build is aborted or
1612    /// `zova_fresh_build_finish` fails.
1613    pub out_node_keys: *mut i64,
1614    pub out_node_keys_capacity: usize,
1615    pub out_edge_keys: *mut i64,
1616    pub out_edge_keys_capacity: usize,
1617}
1618
1619#[repr(C)]
1620pub struct zova_graph_node_get_request {
1621    pub db: *mut zova_database,
1622    pub graph_name: *const c_char,
1623    pub node_id: *const c_char,
1624    pub out_node: *mut zova_graph_node,
1625}
1626
1627#[repr(C)]
1628pub struct zova_graph_node_exists_request {
1629    pub db: *mut zova_database,
1630    pub graph_name: *const c_char,
1631    pub node_id: *const c_char,
1632    pub out_exists: *mut u8,
1633}
1634
1635#[repr(C)]
1636pub struct zova_graph_node_delete_request {
1637    pub db: *mut zova_database,
1638    pub graph_name: *const c_char,
1639    pub node_id: *const c_char,
1640}
1641
1642#[repr(C)]
1643pub struct zova_graph_node_delete_many_request {
1644    pub db: *mut zova_database,
1645    pub graph_name: *const c_char,
1646    pub node_ids: *const *const c_char,
1647    pub node_count: usize,
1648}
1649
1650#[repr(C)]
1651pub struct zova_graph_edge_put_request {
1652    pub db: *mut zova_database,
1653    pub graph_name: *const c_char,
1654    pub from_node_id: *const c_char,
1655    pub edge_type: *const c_char,
1656    pub to_node_id: *const c_char,
1657}
1658
1659#[repr(C)]
1660pub struct zova_graph_edge_input {
1661    pub graph_name: *const c_char,
1662    pub from_node_id: *const c_char,
1663    pub edge_type: *const c_char,
1664    pub to_node_id: *const c_char,
1665}
1666
1667#[repr(C)]
1668pub struct zova_graph_edge_put_many_request {
1669    pub db: *mut zova_database,
1670    pub edges: *const zova_graph_edge_input,
1671    pub edges_len: usize,
1672}
1673
1674#[repr(C)]
1675pub struct zova_graph_edge_put_many_keyed_request {
1676    pub db: *mut zova_database,
1677    pub edges: *const zova_graph_edge_input,
1678    pub edges_len: usize,
1679    pub out_edge_keys: *mut i64,
1680    pub out_edge_keys_capacity: usize,
1681}
1682
1683#[repr(C)]
1684pub struct zova_graph_edge_delete_many_request {
1685    pub db: *mut zova_database,
1686    pub edges: *const zova_graph_edge_input,
1687    pub edges_len: usize,
1688}
1689
1690#[repr(C)]
1691pub struct zova_graph_edge_get_request {
1692    pub db: *mut zova_database,
1693    pub graph_name: *const c_char,
1694    pub from_node_id: *const c_char,
1695    pub edge_type: *const c_char,
1696    pub to_node_id: *const c_char,
1697    pub out_edge: *mut zova_graph_edge,
1698}
1699
1700#[repr(C)]
1701pub struct zova_graph_edge_exists_request {
1702    pub db: *mut zova_database,
1703    pub graph_name: *const c_char,
1704    pub from_node_id: *const c_char,
1705    pub edge_type: *const c_char,
1706    pub to_node_id: *const c_char,
1707    pub out_exists: *mut u8,
1708}
1709
1710#[repr(C)]
1711pub struct zova_graph_edge_delete_request {
1712    pub db: *mut zova_database,
1713    pub graph_name: *const c_char,
1714    pub from_node_id: *const c_char,
1715    pub edge_type: *const c_char,
1716    pub to_node_id: *const c_char,
1717}
1718
1719#[repr(C)]
1720pub struct zova_graph_neighbors_request {
1721    pub db: *mut zova_database,
1722    pub graph_name: *const c_char,
1723    pub node_id: *const c_char,
1724    pub direction: c_int,
1725    pub edge_type: *const c_char,
1726    pub limit: usize,
1727    pub out_results: *mut zova_graph_neighbor_results,
1728}
1729
1730#[repr(C)]
1731pub struct zova_graph_neighbors_keyed_request {
1732    pub db: *mut zova_database,
1733    pub graph_name: *const c_char,
1734    pub node_id: *const c_char,
1735    pub direction: c_int,
1736    pub edge_type: *const c_char,
1737    pub limit: usize,
1738    pub out_results: *mut zova_graph_keyed_neighbor_results,
1739}
1740
1741#[repr(C)]
1742pub struct zova_graph_nodes_get_many_keyed_request {
1743    pub db: *mut zova_database,
1744    pub graph_name: *const c_char,
1745    pub node_keys: *const i64,
1746    pub key_count: usize,
1747    pub out_results: *mut zova_graph_keyed_node_results,
1748}
1749#[repr(C)]
1750pub struct zova_graph_edges_get_many_keyed_request {
1751    pub db: *mut zova_database,
1752    pub graph_name: *const c_char,
1753    pub edge_keys: *const i64,
1754    pub key_count: usize,
1755    pub out_results: *mut zova_graph_keyed_edge_results,
1756}
1757
1758#[repr(C)]
1759pub struct zova_graph_edge_payload_get_many_request {
1760    pub db: *mut zova_database,
1761    pub graph_name: *const c_char,
1762    pub edge_keys: *const i64,
1763    pub key_count: usize,
1764    pub out_results: *mut zova_graph_edge_payload_results,
1765}
1766#[repr(C)]
1767pub struct zova_graph_edge_payload_replacement {
1768    pub edge_key: i64,
1769    pub payload: *const u8,
1770    pub payload_len: usize,
1771}
1772#[repr(C)]
1773pub struct zova_graph_edge_payload_replace_many_request {
1774    pub db: *mut zova_database,
1775    pub graph_name: *const c_char,
1776    pub replacements: *const zova_graph_edge_payload_replacement,
1777    pub replacement_count: usize,
1778}
1779
1780#[repr(C)]
1781pub struct zova_graph_degree_request {
1782    pub db: *mut zova_database,
1783    pub graph_name: *const c_char,
1784    pub node_id: *const c_char,
1785    pub direction: c_int,
1786    pub edge_type: *const c_char,
1787    pub out_degree: *mut u64,
1788}
1789
1790#[repr(C)]
1791pub struct zova_fresh_build_begin_request {
1792    pub db: *mut zova_database,
1793    pub out_build: *mut *mut zova_fresh_build,
1794}
1795#[repr(C)]
1796pub struct zova_fresh_build_rows_request {
1797    pub build: *mut zova_fresh_build,
1798    pub table_name: *const c_char,
1799    pub column_names: *const *const c_char,
1800    pub column_count: usize,
1801    pub values: *const zova_fresh_value,
1802    pub row_count: usize,
1803}
1804#[repr(C)]
1805pub struct zova_fresh_build_graph_request {
1806    pub build: *mut zova_fresh_build,
1807    pub graph_name: *const c_char,
1808    pub nodes: *const zova_graph_fresh_node_input,
1809    pub nodes_len: usize,
1810    pub edges: *const zova_graph_fresh_edge_payload_input,
1811    pub edges_len: usize,
1812    pub out_node_keys: *mut i64,
1813    pub out_node_keys_capacity: usize,
1814    pub out_edge_keys: *mut i64,
1815    pub out_edge_keys_capacity: usize,
1816}
1817#[repr(C)]
1818pub struct zova_fresh_build_vectors_request {
1819    pub build: *mut zova_fresh_build,
1820    pub collection_name: *const c_char,
1821    pub vectors: *const zova_vector_input,
1822    pub vectors_len: usize,
1823}
1824#[repr(C)]
1825pub struct zova_fresh_build_finish_request {
1826    pub build: *mut zova_fresh_build,
1827    pub out_node_keys: *mut i64,
1828    pub out_node_keys_capacity: usize,
1829    pub out_edge_keys: *mut i64,
1830    pub out_edge_keys_capacity: usize,
1831    pub out_profile: *mut zova_fresh_build_profile,
1832}
1833
1834#[repr(C)]
1835pub struct zova_graph_degree_many_keyed_request {
1836    pub db: *mut zova_database,
1837    pub graph_name: *const c_char,
1838    pub node_keys: *const i64,
1839    pub node_count: usize,
1840    pub direction: c_int,
1841    pub edge_type: *const c_char,
1842    pub out_degrees: *mut u64,
1843    pub out_degrees_capacity: usize,
1844}
1845
1846#[repr(C)]
1847pub struct zova_graph_scan_request {
1848    pub db: *mut zova_database,
1849    pub graph_name: *const c_char,
1850    pub node_after: zova_graph_scan_cursor,
1851    pub edge_after: zova_graph_scan_cursor,
1852    pub node_limit: usize,
1853    pub edge_limit: usize,
1854    pub out_results: *mut zova_graph_scan_results,
1855}
1856
1857#[repr(C)]
1858pub struct zova_graph_walk_request {
1859    pub db: *mut zova_database,
1860    pub graph_name: *const c_char,
1861    pub start_node_id: *const c_char,
1862    pub edge_type: *const c_char,
1863    pub max_depth: u32,
1864    pub limit: usize,
1865    pub out_results: *mut zova_graph_walk_results,
1866}
1867
1868extern "C" {
1869    pub fn zova_abi_version_major() -> u32;
1870    pub fn zova_abi_version_minor() -> u32;
1871    pub fn zova_abi_version_patch() -> u32;
1872    pub fn zova_abi_version_string() -> *const c_char;
1873    pub fn zova_status_name(status: zova_status) -> *const c_char;
1874
1875    pub fn zova_buffer_free(buffer: *mut zova_buffer);
1876    pub fn zova_message_free(message: *mut zova_message);
1877    pub fn zova_text_free(text: *mut zova_text);
1878    pub fn zova_notification_free(notification: *mut zova_notification);
1879    pub fn zova_object_manifest_free(manifest: *mut zova_object_manifest);
1880    pub fn zova_vector_free(vector: *mut zova_vector);
1881    pub fn zova_vector_search_results_free(results: *mut zova_vector_search_results);
1882    pub fn zova_vector_collection_info_free(info: *mut zova_vector_collection_info);
1883    pub fn zova_vector_collection_list_free(list: *mut zova_vector_collection_list);
1884
1885    pub fn zova_database_create(request: *const zova_database_open_request) -> zova_status;
1886    pub fn zova_database_create_memory(
1887        request: *const zova_database_create_memory_request,
1888    ) -> zova_status;
1889    pub fn zova_database_create_with_options(
1890        request: *const zova_database_create_options_request,
1891    ) -> zova_status;
1892    pub fn zova_database_create_with_extensions(
1893        request: *const zova_database_open_extensions_request,
1894    ) -> zova_status;
1895    pub fn zova_database_open(request: *const zova_database_open_request) -> zova_status;
1896    pub fn zova_database_open_with_options(
1897        request: *const zova_database_open_options_request,
1898    ) -> zova_status;
1899    pub fn zova_database_open_with_extensions(
1900        request: *const zova_database_open_extensions_request,
1901    ) -> zova_status;
1902    pub fn zova_extension_bundle_verify(
1903        request: *const zova_extension_bundle_request,
1904    ) -> zova_status;
1905    pub fn zova_extension_bundle_trust(
1906        request: *const zova_extension_bundle_request,
1907    ) -> zova_status;
1908    pub fn zova_extension_bundle_untrust(
1909        request: *const zova_extension_bundle_untrust_request,
1910    ) -> zova_status;
1911    pub fn zova_database_close(db: *mut zova_database) -> zova_status;
1912    pub fn zova_database_exec(request: *const zova_database_exec_request) -> zova_status;
1913    pub fn zova_database_register_function(
1914        request: *const zova_sql_function_register_request,
1915    ) -> zova_status;
1916    pub fn zova_database_begin(request: *const zova_database_simple_request) -> zova_status;
1917    pub fn zova_database_begin_immediate(
1918        request: *const zova_database_simple_request,
1919    ) -> zova_status;
1920    pub fn zova_database_commit(request: *const zova_database_simple_request) -> zova_status;
1921    pub fn zova_database_rollback(request: *const zova_database_simple_request) -> zova_status;
1922    pub fn zova_database_savepoint(request: *const zova_database_savepoint_request) -> zova_status;
1923    pub fn zova_database_rollback_to_savepoint(
1924        request: *const zova_database_savepoint_request,
1925    ) -> zova_status;
1926    pub fn zova_database_release_savepoint(
1927        request: *const zova_database_savepoint_request,
1928    ) -> zova_status;
1929    pub fn zova_database_vacuum(request: *const zova_database_simple_request) -> zova_status;
1930    pub fn zova_database_backup(request: *const zova_database_backup_request) -> zova_status;
1931    pub fn zova_database_compact(request: *const zova_database_compact_request) -> zova_status;
1932    pub fn zova_database_backup_with_progress(
1933        request: *const zova_database_backup_progress_request,
1934    ) -> zova_status;
1935    pub fn zova_database_compact_with_progress(
1936        request: *const zova_database_compact_progress_request,
1937    ) -> zova_status;
1938    pub fn zova_database_reclaim(request: *const zova_database_reclaim_request) -> zova_status;
1939    pub fn zova_database_set_busy_timeout(
1940        request: *const zova_database_busy_timeout_request,
1941    ) -> zova_status;
1942    pub fn zova_database_last_insert_rowid(
1943        request: *const zova_database_last_insert_rowid_request,
1944    ) -> zova_status;
1945    pub fn zova_database_changes(request: *const zova_database_changes_request) -> zova_status;
1946    pub fn zova_database_total_changes(
1947        request: *const zova_database_total_changes_request,
1948    ) -> zova_status;
1949    pub fn zova_database_notify(request: *const zova_database_notify_request) -> zova_status;
1950    pub fn zova_database_listen(request: *const zova_database_listen_request) -> zova_status;
1951    pub fn zova_subscription_try_receive(
1952        request: *const zova_subscription_try_receive_request,
1953    ) -> zova_status;
1954    pub fn zova_subscription_close(subscription: *mut zova_subscription) -> zova_status;
1955    pub fn zova_database_prepare(request: *const zova_database_prepare_request) -> zova_status;
1956    pub fn zova_database_last_error_message(db: *mut zova_database) -> *const c_char;
1957    pub fn zova_convert_sqlite_to_zova(
1958        request: *const zova_convert_sqlite_to_zova_request,
1959    ) -> zova_status;
1960    pub fn zova_database_restore(request: *const zova_database_restore_request) -> zova_status;
1961    pub fn zova_database_restore_to_memory(
1962        request: *const zova_database_restore_to_memory_request,
1963    ) -> zova_status;
1964    pub fn zova_database_probe_format(
1965        request: *const zova_database_probe_format_request,
1966    ) -> zova_status;
1967    pub fn zova_database_migrate(request: *const zova_database_migrate_request) -> zova_status;
1968    pub fn zova_database_migrate_with_extensions(
1969        request: *const zova_database_migrate_extensions_request,
1970    ) -> zova_status;
1971    pub fn zova_database_migrate_with_progress(
1972        request: *const zova_database_migrate_progress_request,
1973    ) -> zova_status;
1974
1975    pub fn zova_statement_finalize(statement: *mut zova_statement) -> zova_status;
1976    pub fn zova_statement_step(request: *const zova_statement_step_request) -> zova_status;
1977    pub fn zova_statement_reset(statement: *mut zova_statement) -> zova_status;
1978    pub fn zova_statement_clear_bindings(statement: *mut zova_statement) -> zova_status;
1979    pub fn zova_statement_bind_null(
1980        request: *const zova_statement_bind_null_request,
1981    ) -> zova_status;
1982    pub fn zova_statement_bind_int64(
1983        request: *const zova_statement_bind_int64_request,
1984    ) -> zova_status;
1985    pub fn zova_statement_bind_double(
1986        request: *const zova_statement_bind_double_request,
1987    ) -> zova_status;
1988    pub fn zova_statement_bind_text(
1989        request: *const zova_statement_bind_text_request,
1990    ) -> zova_status;
1991    pub fn zova_statement_bind_blob(
1992        request: *const zova_statement_bind_blob_request,
1993    ) -> zova_status;
1994    pub fn zova_statement_parameter_count(
1995        request: *const zova_statement_parameter_count_request,
1996    ) -> zova_status;
1997    pub fn zova_statement_parameter_index(
1998        request: *const zova_statement_parameter_index_request,
1999    ) -> zova_status;
2000    pub fn zova_statement_column_count(
2001        request: *const zova_statement_column_count_request,
2002    ) -> zova_status;
2003    pub fn zova_statement_column_name(
2004        request: *const zova_statement_column_name_request,
2005    ) -> zova_status;
2006    pub fn zova_statement_column_type(
2007        request: *const zova_statement_column_type_request,
2008    ) -> zova_status;
2009    pub fn zova_statement_column_int64(
2010        request: *const zova_statement_column_int64_request,
2011    ) -> zova_status;
2012    pub fn zova_statement_column_double(
2013        request: *const zova_statement_column_double_request,
2014    ) -> zova_status;
2015    pub fn zova_statement_column_text(
2016        request: *const zova_statement_column_text_request,
2017    ) -> zova_status;
2018    pub fn zova_statement_column_blob(
2019        request: *const zova_statement_column_blob_request,
2020    ) -> zova_status;
2021
2022    pub fn zova_object_id_from_bytes(
2023        data: *const u8,
2024        len: usize,
2025        out_id: *mut zova_object_id,
2026    ) -> zova_status;
2027    pub fn zova_object_chunk_id_from_bytes(
2028        data: *const u8,
2029        len: usize,
2030        out_id: *mut zova_object_chunk_id,
2031    ) -> zova_status;
2032    pub fn zova_object_put(request: *const zova_object_put_request) -> zova_status;
2033    pub fn zova_object_put_with_options(
2034        request: *const zova_object_put_with_options_request,
2035    ) -> zova_status;
2036    pub fn zova_object_get(request: *const zova_object_get_request) -> zova_status;
2037    pub fn zova_object_read_range(request: *const zova_object_read_range_request) -> zova_status;
2038    pub fn zova_object_delete(request: *const zova_object_delete_request) -> zova_status;
2039    pub fn zova_object_exists(request: *const zova_object_exists_request) -> zova_status;
2040    pub fn zova_object_size(request: *const zova_object_size_request) -> zova_status;
2041    pub fn zova_object_chunk_count(request: *const zova_object_chunk_count_request) -> zova_status;
2042    pub fn zova_object_manifest_get(
2043        request: *const zova_object_manifest_get_request,
2044    ) -> zova_status;
2045    pub fn zova_object_chunk_get(request: *const zova_object_chunk_get_request) -> zova_status;
2046    pub fn zova_object_chunk_put(request: *const zova_object_chunk_put_request) -> zova_status;
2047    pub fn zova_object_chunk_put_with_options(
2048        request: *const zova_object_chunk_put_with_options_request,
2049    ) -> zova_status;
2050    pub fn zova_object_chunk_delete(
2051        request: *const zova_object_chunk_delete_request,
2052    ) -> zova_status;
2053    pub fn zova_object_assemble_from_chunks(
2054        request: *const zova_object_assemble_from_chunks_request,
2055    ) -> zova_status;
2056    pub fn zova_object_assemble_from_chunks_with_options(
2057        request: *const zova_object_assemble_from_chunks_with_options_request,
2058    ) -> zova_status;
2059    pub fn zova_object_writer_create(
2060        request: *const zova_object_writer_create_request,
2061    ) -> zova_status;
2062    pub fn zova_object_writer_create_with_options(
2063        request: *const zova_object_writer_create_with_options_request,
2064    ) -> zova_status;
2065    pub fn zova_object_writer_write(
2066        request: *const zova_object_writer_write_request,
2067    ) -> zova_status;
2068    pub fn zova_object_writer_finish(
2069        request: *const zova_object_writer_finish_request,
2070    ) -> zova_status;
2071    pub fn zova_object_writer_cancel(
2072        request: *const zova_object_writer_cancel_request,
2073    ) -> zova_status;
2074    pub fn zova_object_writer_destroy(writer: *mut zova_object_writer) -> zova_status;
2075    pub fn zova_object_reader_create(
2076        request: *const zova_object_reader_create_request,
2077    ) -> zova_status;
2078    pub fn zova_object_reader_read(request: *const zova_object_reader_read_request) -> zova_status;
2079    pub fn zova_object_reader_destroy(
2080        request: *const zova_object_reader_destroy_request,
2081    ) -> zova_status;
2082    pub fn zova_object_seekable_reader_create(
2083        request: *const zova_object_seekable_reader_create_request,
2084    ) -> zova_status;
2085    pub fn zova_object_seekable_reader_read(
2086        request: *const zova_object_seekable_reader_read_request,
2087    ) -> zova_status;
2088    pub fn zova_object_seekable_reader_seek(
2089        request: *const zova_object_seekable_reader_seek_request,
2090    ) -> zova_status;
2091    pub fn zova_object_seekable_reader_destroy(
2092        request: *const zova_object_seekable_reader_destroy_request,
2093    ) -> zova_status;
2094
2095    pub fn zova_vector_collection_create(
2096        request: *const zova_vector_collection_create_request,
2097    ) -> zova_status;
2098    pub fn zova_vector_collection_exists(
2099        request: *const zova_vector_collection_exists_request,
2100    ) -> zova_status;
2101    pub fn zova_vector_collection_info_get(
2102        request: *const zova_vector_collection_info_get_request,
2103    ) -> zova_status;
2104    pub fn zova_vector_collections_list(
2105        request: *const zova_vector_collections_list_request,
2106    ) -> zova_status;
2107    pub fn zova_vector_put(request: *const zova_vector_put_request) -> zova_status;
2108    pub fn zova_vector_put_many(request: *const zova_vector_put_many_request) -> zova_status;
2109    pub fn zova_vector_delete_many(request: *const zova_vector_delete_many_request) -> zova_status;
2110    pub fn zova_vector_get(request: *const zova_vector_get_request) -> zova_status;
2111    pub fn zova_vector_exists(request: *const zova_vector_exists_request) -> zova_status;
2112    pub fn zova_vector_delete(request: *const zova_vector_delete_request) -> zova_status;
2113    pub fn zova_vector_collection_delete(
2114        request: *const zova_vector_collection_delete_request,
2115    ) -> zova_status;
2116    pub fn zova_vector_search(request: *const zova_vector_search_request) -> zova_status;
2117    pub fn zova_vector_search_in(request: *const zova_vector_search_in_request) -> zova_status;
2118    pub fn zova_vector_search_within(
2119        request: *const zova_vector_search_within_request,
2120    ) -> zova_status;
2121    pub fn zova_vector_search_in_within(
2122        request: *const zova_vector_search_in_within_request,
2123    ) -> zova_status;
2124    pub fn zova_vector_search_by_id(
2125        request: *const zova_vector_search_by_id_request,
2126    ) -> zova_status;
2127    pub fn zova_vector_search_by_id_in(
2128        request: *const zova_vector_search_by_id_in_request,
2129    ) -> zova_status;
2130    pub fn zova_vector_search_by_id_within(
2131        request: *const zova_vector_search_by_id_within_request,
2132    ) -> zova_status;
2133    pub fn zova_vector_search_by_id_in_within(
2134        request: *const zova_vector_search_by_id_in_within_request,
2135    ) -> zova_status;
2136
2137    pub fn zova_graph_info_free(info: *mut zova_graph_info);
2138    pub fn zova_graph_list_free(list: *mut zova_graph_list);
2139    pub fn zova_extension_info_free(info: *mut zova_extension_info);
2140    pub fn zova_extension_list_free(list: *mut zova_extension_list);
2141    pub fn zova_graph_node_free(node: *mut zova_graph_node);
2142    pub fn zova_graph_edge_free(edge: *mut zova_graph_edge);
2143    pub fn zova_graph_neighbor_results_free(results: *mut zova_graph_neighbor_results);
2144    pub fn zova_graph_keyed_neighbor_results_free(results: *mut zova_graph_keyed_neighbor_results);
2145    pub fn zova_graph_keyed_node_results_free(results: *mut zova_graph_keyed_node_results);
2146    pub fn zova_graph_keyed_edge_results_free(results: *mut zova_graph_keyed_edge_results);
2147    pub fn zova_graph_edge_payload_results_free(results: *mut zova_graph_edge_payload_results);
2148    pub fn zova_fresh_build_begin(request: *const zova_fresh_build_begin_request) -> zova_status;
2149    pub fn zova_fresh_build_table_rows(
2150        request: *const zova_fresh_build_rows_request,
2151    ) -> zova_status;
2152    pub fn zova_fresh_build_fts_rows(request: *const zova_fresh_build_rows_request) -> zova_status;
2153    pub fn zova_fresh_build_graph(request: *const zova_fresh_build_graph_request) -> zova_status;
2154    pub fn zova_fresh_build_vectors(
2155        request: *const zova_fresh_build_vectors_request,
2156    ) -> zova_status;
2157    pub fn zova_fresh_build_finish(request: *const zova_fresh_build_finish_request) -> zova_status;
2158    pub fn zova_fresh_build_abort(build: *mut zova_fresh_build) -> zova_status;
2159    pub fn zova_fresh_build_destroy(build: *mut zova_fresh_build);
2160    pub fn zova_graph_scan_results_free(results: *mut zova_graph_scan_results);
2161    pub fn zova_graph_walk_results_free(results: *mut zova_graph_walk_results);
2162    pub fn zova_graph_create(request: *const zova_graph_create_request) -> zova_status;
2163    pub fn zova_graph_exists(request: *const zova_graph_exists_request) -> zova_status;
2164    pub fn zova_graph_info_get(request: *const zova_graph_info_get_request) -> zova_status;
2165    pub fn zova_graphs_list(request: *const zova_graph_list_request) -> zova_status;
2166    pub fn zova_database_extension_install(
2167        request: *const zova_database_extension_request,
2168    ) -> zova_status;
2169    pub fn zova_database_extension_upgrade(
2170        request: *const zova_database_extension_request,
2171    ) -> zova_status;
2172    pub fn zova_database_extension_rebuild(
2173        request: *const zova_database_extension_request,
2174    ) -> zova_status;
2175    pub fn zova_database_open_for_extension_upgrade(
2176        request: *const zova_database_open_extensions_request,
2177    ) -> zova_status;
2178    pub fn zova_database_create_with_plugins(
2179        request: *const zova_database_open_plugins_request,
2180    ) -> zova_status;
2181    pub fn zova_database_open_with_plugins(
2182        request: *const zova_database_open_plugins_request,
2183    ) -> zova_status;
2184    pub fn zova_database_open_for_extension_upgrade_with_plugins(
2185        request: *const zova_database_open_plugins_request,
2186    ) -> zova_status;
2187    pub fn zova_database_extension_list(
2188        request: *const zova_database_extension_list_request,
2189    ) -> zova_status;
2190    pub fn zova_database_extension_info(
2191        request: *const zova_database_extension_info_request,
2192    ) -> zova_status;
2193    pub fn zova_database_extension_check(
2194        request: *const zova_database_extension_request,
2195    ) -> zova_status;
2196    pub fn zova_database_extension_check_all(
2197        request: *const zova_database_simple_request,
2198    ) -> zova_status;
2199    pub fn zova_database_extension_drop(
2200        request: *const zova_database_extension_request,
2201    ) -> zova_status;
2202    pub fn zova_graph_delete(request: *const zova_graph_delete_request) -> zova_status;
2203    pub fn zova_graph_node_put(request: *const zova_graph_node_put_request) -> zova_status;
2204    pub fn zova_graph_node_put_many(
2205        request: *const zova_graph_node_put_many_request,
2206    ) -> zova_status;
2207    pub fn zova_graph_node_put_many_keyed(
2208        request: *const zova_graph_node_put_many_keyed_request,
2209    ) -> zova_status;
2210    pub fn zova_graph_build_fresh_keyed(
2211        request: *const zova_graph_build_fresh_keyed_request,
2212    ) -> zova_status;
2213    /// Trusted final-order, deduplicated ordinal-topology build.
2214    pub fn zova_graph_build_fresh_prepared_keyed(
2215        request: *const zova_graph_build_fresh_keyed_request,
2216    ) -> zova_status;
2217    pub fn zova_graph_build_fresh_prepared_keyed_with_payloads(
2218        request: *const zova_graph_build_fresh_prepared_keyed_with_payloads_request,
2219    ) -> zova_status;
2220    pub fn zova_graph_node_get(request: *const zova_graph_node_get_request) -> zova_status;
2221    pub fn zova_graph_node_exists(request: *const zova_graph_node_exists_request) -> zova_status;
2222    pub fn zova_graph_node_delete(request: *const zova_graph_node_delete_request) -> zova_status;
2223    pub fn zova_graph_node_delete_many(
2224        request: *const zova_graph_node_delete_many_request,
2225    ) -> zova_status;
2226    pub fn zova_graph_edge_put(request: *const zova_graph_edge_put_request) -> zova_status;
2227    pub fn zova_graph_edge_put_many(
2228        request: *const zova_graph_edge_put_many_request,
2229    ) -> zova_status;
2230    pub fn zova_graph_edge_put_many_keyed(
2231        request: *const zova_graph_edge_put_many_keyed_request,
2232    ) -> zova_status;
2233    pub fn zova_graph_edge_get(request: *const zova_graph_edge_get_request) -> zova_status;
2234    pub fn zova_graph_edge_exists(request: *const zova_graph_edge_exists_request) -> zova_status;
2235    pub fn zova_graph_edge_delete(request: *const zova_graph_edge_delete_request) -> zova_status;
2236    pub fn zova_graph_edge_delete_many(
2237        request: *const zova_graph_edge_delete_many_request,
2238    ) -> zova_status;
2239    pub fn zova_graph_neighbors(request: *const zova_graph_neighbors_request) -> zova_status;
2240    pub fn zova_graph_neighbors_keyed(
2241        request: *const zova_graph_neighbors_keyed_request,
2242    ) -> zova_status;
2243    pub fn zova_graph_nodes_get_many_keyed(
2244        request: *const zova_graph_nodes_get_many_keyed_request,
2245    ) -> zova_status;
2246    pub fn zova_graph_edges_get_many_keyed(
2247        request: *const zova_graph_edges_get_many_keyed_request,
2248    ) -> zova_status;
2249    pub fn zova_graph_edge_payload_get_many(
2250        request: *const zova_graph_edge_payload_get_many_request,
2251    ) -> zova_status;
2252    pub fn zova_graph_edge_payload_replace_many(
2253        request: *const zova_graph_edge_payload_replace_many_request,
2254    ) -> zova_status;
2255    pub fn zova_graph_degree(request: *const zova_graph_degree_request) -> zova_status;
2256    pub fn zova_graph_degree_many_keyed(
2257        request: *const zova_graph_degree_many_keyed_request,
2258    ) -> zova_status;
2259    pub fn zova_graph_scan(request: *const zova_graph_scan_request) -> zova_status;
2260    pub fn zova_graph_walk(request: *const zova_graph_walk_request) -> zova_status;
2261    pub fn zova_kv_get(request: *const zova_kv_get_request) -> zova_status;
2262    pub fn zova_kv_get_many(request: *const zova_kv_get_many_request) -> zova_status;
2263    pub fn zova_kv_put(request: *const zova_kv_put_request) -> zova_status;
2264    pub fn zova_kv_put_many(request: *const zova_kv_put_many_request) -> zova_status;
2265    pub fn zova_kv_delete(request: *const zova_kv_delete_request) -> zova_status;
2266    pub fn zova_kv_delete_many(request: *const zova_kv_delete_many_request) -> zova_status;
2267    pub fn zova_kv_count(request: *const zova_kv_count_request) -> zova_status;
2268    pub fn zova_kv_clear_namespace(request: *const zova_kv_clear_namespace_request) -> zova_status;
2269    pub fn zova_kv_get_result_free(result: *mut zova_kv_get_result);
2270    pub fn zova_kv_get_many_results_free(results: *mut zova_kv_get_many_results);
2271}