/* automatically generated by rust-bindgen 0.71.1 */

use turso_sdk_kit::capi::c::*;

#[repr(u32)]
#[doc = " TURSO_DATABASE_SYNC_IO_REQUEST"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum turso_sync_io_request_type_t {
    TURSO_SYNC_IO_NONE = 0,
    TURSO_SYNC_IO_HTTP = 1,
    TURSO_SYNC_IO_FULL_READ = 2,
    TURSO_SYNC_IO_FULL_WRITE = 3,
}
#[repr(C)]
pub struct turso_sync_io_http_request_t {
    pub url: turso_slice_ref_t,
    pub method: turso_slice_ref_t,
    pub path: turso_slice_ref_t,
    pub body: turso_slice_ref_t,
    pub headers: i32,
}
impl Default for turso_sync_io_http_request_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct turso_sync_io_http_header_t {
    pub key: turso_slice_ref_t,
    pub value: turso_slice_ref_t,
}
impl Default for turso_sync_io_http_header_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct turso_sync_io_full_read_request_t {
    pub path: turso_slice_ref_t,
}
impl Default for turso_sync_io_full_read_request_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct turso_sync_io_full_write_request_t {
    pub path: turso_slice_ref_t,
    pub content: turso_slice_ref_t,
}
impl Default for turso_sync_io_full_write_request_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(u32)]
#[doc = " TURSO_ASYNC_OPERATION_RESULT"]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum turso_sync_operation_result_type_t {
    TURSO_ASYNC_RESULT_NONE = 0,
    TURSO_ASYNC_RESULT_CONNECTION = 1,
    TURSO_ASYNC_RESULT_CHANGES = 2,
    TURSO_ASYNC_RESULT_STATS = 3,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct turso_sync_changes {
    _unused: [u8; 0],
}
#[doc = " opaque pointer to the TursoDatabaseSyncChanges instance\n SAFETY: turso_sync_changes_t have independent lifetime and must be explicitly deallocated with turso_sync_changes_deinit method OR passed to the turso_sync_database_apply_changes method which gather ownership to this object"]
pub type turso_sync_changes_t = turso_sync_changes;
#[doc = " structure holding opaque pointer to the SyncEngineStats instance\n SAFETY: revision string will be valid only during async operation lifetime (until turso_sync_operation_deinit)\n Most likely, caller will need to copy revision slice to its internal buffer for longer lifetime"]
#[repr(C)]
pub struct turso_sync_stats_t {
    pub cdc_operations: i64,
    pub main_wal_size: i64,
    pub revert_wal_size: i64,
    pub last_pull_unix_time: i64,
    pub last_push_unix_time: i64,
    pub network_sent_bytes: i64,
    pub network_received_bytes: i64,
    pub revision: turso_slice_ref_t,
}
impl Default for turso_sync_stats_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[doc = " Database sync description."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct turso_sync_database_config_t {
    pub path: *const ::std::os::raw::c_char,
    pub remote_url: *const ::std::os::raw::c_char,
    pub client_name: *const ::std::os::raw::c_char,
    pub long_poll_timeout_ms: i32,
    pub bootstrap_if_empty: bool,
    pub reserved_bytes: i32,
    pub partial_bootstrap_strategy_prefix: i32,
    pub partial_bootstrap_strategy_query: *const ::std::os::raw::c_char,
    pub partial_bootstrap_segment_size: usize,
    pub partial_bootstrap_prefetch: bool,
    pub remote_encryption_key: *const ::std::os::raw::c_char,
    pub remote_encryption_cipher: *const ::std::os::raw::c_char,
}
impl Default for turso_sync_database_config_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct turso_sync_database {
    _unused: [u8; 0],
}
#[doc = " opaque pointer to the TursoDatabaseSync instance"]
pub type turso_sync_database_t = turso_sync_database;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct turso_sync_operation {
    _unused: [u8; 0],
}
#[doc = " opaque pointer to the TursoAsyncOperation instance\n SAFETY: methods for the turso_sync_operation_t can't be called concurrently"]
pub type turso_sync_operation_t = turso_sync_operation;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct turso_sync_io_item {
    _unused: [u8; 0],
}
#[doc = " opaque pointer to the SyncEngineIoQueueItem instance"]
pub type turso_sync_io_item_t = turso_sync_io_item;
unsafe extern "C" {
    #[doc = " Create database sync holder but do not open it"]
    pub fn turso_sync_database_new(
        db_config: *const turso_database_config_t,
        sync_config: *const turso_sync_database_config_t,
        database: *mut *const turso_sync_database_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Open prepared synced database, fail if no properly setup database exists\n AsyncOperation returns None"]
    pub fn turso_sync_database_open(
        self_: *const turso_sync_database_t,
        operation: *mut *const turso_sync_operation_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Open or prepared synced database or create it if no properly setup database exists\n AsyncOperation returns None"]
    pub fn turso_sync_database_create(
        self_: *const turso_sync_database_t,
        operation: *mut *const turso_sync_operation_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Create turso database connection\n SAFETY: synced database must be opened before that operation (with either turso_database_sync_create or turso_database_sync_open)\n AsyncOperation returns Connection"]
    pub fn turso_sync_database_connect(
        self_: *const turso_sync_database_t,
        operation: *mut *const turso_sync_operation_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Collect stats about synced database\n AsyncOperation returns Stats"]
    pub fn turso_sync_database_stats(
        self_: *const turso_sync_database_t,
        operation: *mut *const turso_sync_operation_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Checkpoint WAL of the synced database\n AsyncOperation returns None"]
    pub fn turso_sync_database_checkpoint(
        self_: *const turso_sync_database_t,
        operation: *mut *const turso_sync_operation_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Push local changes to remote\n AsyncOperation returns None"]
    pub fn turso_sync_database_push_changes(
        self_: *const turso_sync_database_t,
        operation: *mut *const turso_sync_operation_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Wait for remote changes\n AsyncOperation returns Changes (which must be properly deinited or used in the [turso_sync_database_apply_changes] method)"]
    pub fn turso_sync_database_wait_changes(
        self_: *const turso_sync_database_t,
        operation: *mut *const turso_sync_operation_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Apply remote changes locally\n SAFETY: caller must guarantee that no other methods are executing concurrently (push/wait/checkpoint)\n otherwise, operation will return MISUSE error\n\n the method CONSUMES turso_sync_changes_t instance and caller no longer owns it after the call\n So, the changes MUST NOT be explicitly deallocated after the method call (either successful or not)\n\n AsyncOperation returns None"]
    pub fn turso_sync_database_apply_changes(
        self_: *const turso_sync_database_t,
        changes: *const turso_sync_changes_t,
        operation: *mut *const turso_sync_operation_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Resume async operation\n If return TURSO_IO - caller must drive IO\n If return TURSO_DONE - caller must inspect result and clean up it or use it accordingly\n It's safe to call turso_sync_operation_resume multiple times even after operation completion (in case of repeat calls after completion - final result always will be returned)"]
    pub fn turso_sync_operation_resume(
        self_: *const turso_sync_operation_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Extract operation result kind"]
    pub fn turso_sync_operation_result_kind(
        self_: *const turso_sync_operation_t,
    ) -> turso_sync_operation_result_type_t;
}
unsafe extern "C" {
    #[doc = " Extract Connection result from finished async operation"]
    pub fn turso_sync_operation_result_extract_connection(
        self_: *const turso_sync_operation_t,
        connection: *mut *const turso_connection_t,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Extract Changes result from finished async operation\n If no changes were fetched - return TURSO_OK and set changes to null pointer"]
    pub fn turso_sync_operation_result_extract_changes(
        self_: *const turso_sync_operation_t,
        changes: *mut *const turso_sync_changes_t,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Extract Stats result from finished async operation"]
    pub fn turso_sync_operation_result_extract_stats(
        self_: *const turso_sync_operation_t,
        stats: *mut turso_sync_stats_t,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Try to take IO request from the sync engine IO queue"]
    pub fn turso_sync_database_io_take_item(
        self_: *const turso_sync_database_t,
        item: *mut *const turso_sync_io_item_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Run extra database callbacks after IO execution"]
    pub fn turso_sync_database_io_step_callbacks(
        self_: *const turso_sync_database_t,
        error_opt_out: *mut *const ::std::os::raw::c_char,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Get request IO kind"]
    pub fn turso_sync_database_io_request_kind(
        self_: *const turso_sync_io_item_t,
    ) -> turso_sync_io_request_type_t;
}
unsafe extern "C" {
    #[doc = " Get HTTP request header key-value pair"]
    pub fn turso_sync_database_io_request_http(
        self_: *const turso_sync_io_item_t,
        request: *mut turso_sync_io_http_request_t,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Get HTTP request fields"]
    pub fn turso_sync_database_io_request_http_header(
        self_: *const turso_sync_io_item_t,
        index: usize,
        header: *mut turso_sync_io_http_header_t,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Get HTTP request fields"]
    pub fn turso_sync_database_io_request_full_read(
        self_: *const turso_sync_io_item_t,
        request: *mut turso_sync_io_full_read_request_t,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Get HTTP request fields"]
    pub fn turso_sync_database_io_request_full_write(
        self_: *const turso_sync_io_item_t,
        request: *mut turso_sync_io_full_write_request_t,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Poison IO request completion with error"]
    pub fn turso_sync_database_io_poison(
        self_: *const turso_sync_io_item_t,
        error: *mut turso_slice_ref_t,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Set IO request completion status"]
    pub fn turso_sync_database_io_status(
        self_: *const turso_sync_io_item_t,
        status: i32,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Push bytes to the IO completion buffer"]
    pub fn turso_sync_database_io_push_buffer(
        self_: *const turso_sync_io_item_t,
        buffer: *mut turso_slice_ref_t,
    ) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Set IO request completion as done"]
    pub fn turso_sync_database_io_done(self_: *const turso_sync_io_item_t) -> turso_status_code_t;
}
unsafe extern "C" {
    #[doc = " Deallocate a TursoDatabaseSync"]
    pub fn turso_sync_database_deinit(self_: *const turso_sync_database_t);
}
unsafe extern "C" {
    #[doc = " Deallocate a TursoAsyncOperation"]
    pub fn turso_sync_operation_deinit(self_: *const turso_sync_operation_t);
}
unsafe extern "C" {
    #[doc = " Deallocate a SyncEngineIoQueueItem"]
    pub fn turso_sync_database_io_item_deinit(self_: *const turso_sync_io_item_t);
}
unsafe extern "C" {
    #[doc = " Deallocate a TursoDatabaseSyncChanges"]
    pub fn turso_sync_changes_deinit(self_: *const turso_sync_changes_t);
}
