@dbx-tools/core-rs 0.6.188

package/lib/index.js

@@ -0,0 +1,2223 @@
+// src/_bindings-ffi.ts
+import lib from "@ubjs/node";
+var { UniffiNativeModule, FfiType, resolveLibPath } = lib;
+var DEFINITIONS = {
+  symbols: {
+    rustbuffer_alloc: "ffi_dbx_tools_core_rustbuffer_alloc",
+    rustbuffer_free: "ffi_dbx_tools_core_rustbuffer_free",
+    rustbuffer_from_bytes: "ffi_dbx_tools_core_rustbuffer_from_bytes"
+  },
+  functions: {
+    ffi_dbx_tools_core_rust_future_poll_u8: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_u8: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_u8: {
+      args: [FfiType.Handle],
+      ret: FfiType.UInt8,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_u8: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_poll_i8: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_i8: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_i8: {
+      args: [FfiType.Handle],
+      ret: FfiType.Int8,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_i8: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_poll_u16: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_u16: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_u16: {
+      args: [FfiType.Handle],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_u16: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_poll_i16: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_i16: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_i16: {
+      args: [FfiType.Handle],
+      ret: FfiType.Int16,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_i16: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_poll_u32: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_u32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_u32: {
+      args: [FfiType.Handle],
+      ret: FfiType.UInt32,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_u32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_poll_i32: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_i32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_i32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Int32,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_i32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_poll_u64: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_u64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_u64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_u64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_poll_i64: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_i64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_i64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Int64,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_i64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_poll_f32: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_f32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_f32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Float32,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_f32: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_poll_f64: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_f64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_f64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Float64,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_f64: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_poll_rust_buffer: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_rust_buffer: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_rust_buffer: {
+      args: [FfiType.Handle],
+      ret: FfiType.RustBuffer,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_rust_buffer: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_poll_void: {
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_cancel_void: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ffi_dbx_tools_core_rust_future_complete_void: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_rust_future_free_void: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_clone_persistentauth: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_free_persistentauth: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_clone_providerauth: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_free_providerauth: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_clone_storageadapter: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_free_storageadapter: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_clone_storagehandle: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_free_storagehandle: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_init_callback_vtable_storageadapter: {
+      args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceDbxToolsCoreStorageAdapter"))],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_func_canonical_scopes: {
+      args: [FfiType.RustBuffer],
+      ret: FfiType.RustBuffer,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_func_create_persistent_auth: {
+      args: [FfiType.RustBuffer, FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_func_create_persistent_auth_with_storage: {
+      args: [FfiType.RustBuffer, FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_func_create_provider_auth: {
+      args: [FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_func_create_provider_auth_with_storage: {
+      args: [FfiType.RustBuffer, FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_func_create_storage_handle: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_func_credential_key: {
+      args: [FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer],
+      ret: FfiType.RustBuffer,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_func_databricks_cli_available: {
+      args: [],
+      ret: FfiType.Int8,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_func_is_databricks_app: {
+      args: [],
+      ret: FfiType.Int8,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_func_parse_address: {
+      args: [FfiType.RustBuffer],
+      ret: FfiType.RustBuffer,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_func_parse_resource_path: {
+      args: [FfiType.RustBuffer],
+      ret: FfiType.RustBuffer,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_method_persistentauth_authorization_header_for_url: {
+      args: [FfiType.Handle, FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_persistentauth_challenge: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_persistentauth_force_refresh_token: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_persistentauth_logout: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_persistentauth_refresh_rejected_token: {
+      args: [FfiType.Handle, FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_persistentauth_status: {
+      args: [FfiType.Handle],
+      ret: FfiType.RustBuffer,
+      hasRustCallStatus: true
+    },
+    uniffi_dbx_tools_core_fn_method_persistentauth_token: {
+      args: [FfiType.Handle, FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_providerauth_force_refresh_token: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_providerauth_logout: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_providerauth_refresh_rejected_token: {
+      args: [FfiType.Handle, FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_providerauth_token: {
+      args: [FfiType.Handle, FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_storageadapter_load: {
+      args: [FfiType.Handle, FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_storageadapter_prepare_write: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_storageadapter_save: {
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_storageadapter_remove: {
+      args: [FfiType.Handle, FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_storageadapter_acquire_lock: {
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.UInt64],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_storageadapter_release_lock: {
+      args: [FfiType.Handle, FfiType.RustBuffer],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_fn_method_storageadapter_name: {
+      args: [FfiType.Handle],
+      ret: FfiType.RustBuffer,
+      hasRustCallStatus: true
+    },
+    ffi_dbx_tools_core_uniffi_contract_version: {
+      args: [],
+      ret: FfiType.UInt32,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_func_canonical_scopes: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_func_create_persistent_auth: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_func_create_persistent_auth_with_storage: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_func_create_provider_auth: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_func_create_provider_auth_with_storage: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_func_create_storage_handle: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_func_credential_key: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_func_databricks_cli_available: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_func_is_databricks_app: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_func_parse_address: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_func_parse_resource_path: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_persistentauth_authorization_header_for_url: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_persistentauth_challenge: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_persistentauth_force_refresh_token: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_persistentauth_logout: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_persistentauth_refresh_rejected_token: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_persistentauth_status: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_persistentauth_token: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_providerauth_force_refresh_token: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_providerauth_logout: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_providerauth_refresh_rejected_token: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_providerauth_token: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_storageadapter_load: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_storageadapter_prepare_write: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_storageadapter_save: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_storageadapter_remove: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_storageadapter_acquire_lock: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_storageadapter_release_lock: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    },
+    uniffi_dbx_tools_core_checksum_method_storageadapter_name: {
+      args: [],
+      ret: FfiType.UInt16,
+      hasRustCallStatus: false
+    }
+  },
+  callbacks: {
+    RustFutureContinuationCallback: {
+      args: [FfiType.Handle, FfiType.Int8],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ForeignFutureDroppedCallback: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    ForeignFutureCompleterust_buffer: {
+      args: [FfiType.Handle, FfiType.Struct("ForeignFutureResultRustBuffer")],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    CallbackInterfaceDbxToolsCoreStorageAdapterMethod0: {
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.Callback("ForeignFutureCompleterust_buffer"), FfiType.Handle],
+      ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+      hasRustCallStatus: false,
+      outReturn: true
+    },
+    ForeignFutureCompletevoid: {
+      args: [FfiType.Handle, FfiType.Struct("ForeignFutureResultVoid")],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    },
+    CallbackInterfaceDbxToolsCoreStorageAdapterMethod1: {
+      args: [FfiType.Handle, FfiType.Callback("ForeignFutureCompletevoid"), FfiType.Handle],
+      ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+      hasRustCallStatus: false,
+      outReturn: true
+    },
+    CallbackInterfaceDbxToolsCoreStorageAdapterMethod2: {
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.Callback("ForeignFutureCompletevoid"), FfiType.Handle],
+      ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+      hasRustCallStatus: false,
+      outReturn: true
+    },
+    CallbackInterfaceDbxToolsCoreStorageAdapterMethod3: {
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.Callback("ForeignFutureCompletevoid"), FfiType.Handle],
+      ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+      hasRustCallStatus: false,
+      outReturn: true
+    },
+    CallbackInterfaceDbxToolsCoreStorageAdapterMethod4: {
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.UInt64, FfiType.Callback("ForeignFutureCompleterust_buffer"), FfiType.Handle],
+      ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+      hasRustCallStatus: false,
+      outReturn: true
+    },
+    CallbackInterfaceDbxToolsCoreStorageAdapterMethod5: {
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.Callback("ForeignFutureCompletevoid"), FfiType.Handle],
+      ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
+      hasRustCallStatus: false,
+      outReturn: true
+    },
+    CallbackInterfaceDbxToolsCoreStorageAdapterMethod6: {
+      args: [FfiType.Handle],
+      ret: FfiType.RustBuffer,
+      hasRustCallStatus: true,
+      outReturn: true
+    },
+    CallbackInterfaceCloneDbxToolsCore_StorageAdapter: {
+      args: [FfiType.Handle],
+      ret: FfiType.Handle,
+      hasRustCallStatus: false
+    },
+    CallbackInterfaceFreeDbxToolsCore_StorageAdapter: {
+      args: [FfiType.Handle],
+      ret: FfiType.Void,
+      hasRustCallStatus: false
+    }
+  },
+  structs: {
+    ForeignFutureDroppedCallbackStruct: [
+      { name: "handle", type: FfiType.Handle },
+      { name: "free", type: FfiType.Callback("ForeignFutureDroppedCallback") }
+    ],
+    ForeignFutureResultRustBuffer: [
+      { name: "return_value", type: FfiType.RustBuffer },
+      { name: "call_status", type: FfiType.RustCallStatus }
+    ],
+    ForeignFutureResultVoid: [
+      { name: "call_status", type: FfiType.RustCallStatus }
+    ],
+    VTableCallbackInterfaceDbxToolsCoreStorageAdapter: [
+      { name: "uniffi_free", type: FfiType.Callback("CallbackInterfaceFreeDbxToolsCore_StorageAdapter") },
+      { name: "uniffi_clone", type: FfiType.Callback("CallbackInterfaceCloneDbxToolsCore_StorageAdapter") },
+      { name: "load", type: FfiType.Callback("CallbackInterfaceDbxToolsCoreStorageAdapterMethod0") },
+      { name: "prepare_write", type: FfiType.Callback("CallbackInterfaceDbxToolsCoreStorageAdapterMethod1") },
+      { name: "save", type: FfiType.Callback("CallbackInterfaceDbxToolsCoreStorageAdapterMethod2") },
+      { name: "remove", type: FfiType.Callback("CallbackInterfaceDbxToolsCoreStorageAdapterMethod3") },
+      { name: "acquire_lock", type: FfiType.Callback("CallbackInterfaceDbxToolsCoreStorageAdapterMethod4") },
+      { name: "release_lock", type: FfiType.Callback("CallbackInterfaceDbxToolsCoreStorageAdapterMethod5") },
+      { name: "name", type: FfiType.Callback("CallbackInterfaceDbxToolsCoreStorageAdapterMethod6") }
+    ]
+  }
+};
+var _nativeModule;
+var getter = () => {
+  if (!_nativeModule) {
+    const libPath = resolveLibPath({
+      crateName: "dbx_tools_core",
+      callerUrl: import.meta.url,
+      npmPackageBase: "@dbx-tools/core-rs-",
+      tripleStyle: "node"
+    });
+    const mod_ = UniffiNativeModule.open(libPath);
+    _nativeModule = mod_.register(DEFINITIONS);
+  }
+  return _nativeModule;
+};
+var _bindings_ffi_default = getter;
+
+// src/_bindings.ts
+import {
+  AbstractFfiConverterByteArray,
+  FfiConverterArray,
+  FfiConverterBool,
+  FfiConverterInt64,
+  FfiConverterMap,
+  FfiConverterObject,
+  FfiConverterObjectWithCallbacks,
+  FfiConverterOptional,
+  FfiConverterUInt16,
+  FfiConverterUInt64,
+  UniffiAbstractObject,
+  UniffiError,
+  UniffiInternalError,
+  UniffiResult,
+  UniffiRustCaller,
+  destructorGuardSymbol,
+  pointerLiteralSymbol,
+  uniffiCreateFfiConverterString,
+  uniffiCreateRecord,
+  uniffiRustCallAsync,
+  uniffiTraitInterfaceCall,
+  uniffiTraitInterfaceCallAsyncWithError,
+  uniffiTypeNameSymbol
+} from "@ubjs/core";
+var uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
+var uniffiIsDebug = typeof process !== "object" || process?.env?.NODE_ENV !== "production" || false;
+function canonicalScopes(scopes) {
+  const __rb = uniffiCaller.rustCall((callStatus) => {
+    return _bindings_ffi_default().uniffi_dbx_tools_core_fn_func_canonical_scopes(FfiConverterSequenceString.lower(scopes, _bindings_ffi_default().rustbuffer_alloc), callStatus);
+  }, FfiConverterString.lift.bind(FfiConverterString));
+  try {
+    return FfiConverterSequenceString.lift(__rb);
+  } finally {
+    _bindings_ffi_default().rustbuffer_free(__rb);
+  }
+}
+async function createPersistentAuth(options, storage = undefined, asyncOpts_) {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(uniffiCaller, () => {
+      return _bindings_ffi_default().uniffi_dbx_tools_core_fn_func_create_persistent_auth(FfiConverterTypeDatabricksAuthOptions.lower(options, _bindings_ffi_default().rustbuffer_alloc), FfiConverterOptionalTypeStorage.lower(storage, _bindings_ffi_default().rustbuffer_alloc));
+    }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_u64, FfiConverterTypePersistentAuth.lift.bind(FfiConverterTypePersistentAuth), FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+  } catch (__error) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+async function createPersistentAuthWithStorage(options, storage, asyncOpts_) {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(uniffiCaller, () => {
+      return _bindings_ffi_default().uniffi_dbx_tools_core_fn_func_create_persistent_auth_with_storage(FfiConverterTypeDatabricksAuthOptions.lower(options, _bindings_ffi_default().rustbuffer_alloc), FfiConverterTypeStorageHandle.lower(storage, _bindings_ffi_default().rustbuffer_alloc));
+    }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_u64, FfiConverterTypePersistentAuth.lift.bind(FfiConverterTypePersistentAuth), FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+  } catch (__error) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+async function createProviderAuth(options, asyncOpts_) {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(uniffiCaller, () => {
+      return _bindings_ffi_default().uniffi_dbx_tools_core_fn_func_create_provider_auth(FfiConverterTypeProviderOptions.lower(options, _bindings_ffi_default().rustbuffer_alloc));
+    }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_u64, FfiConverterTypeProviderAuth.lift.bind(FfiConverterTypeProviderAuth), FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+  } catch (__error) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+async function createProviderAuthWithStorage(options, storage, asyncOpts_) {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(uniffiCaller, () => {
+      return _bindings_ffi_default().uniffi_dbx_tools_core_fn_func_create_provider_auth_with_storage(FfiConverterTypeProviderOptions.lower(options, _bindings_ffi_default().rustbuffer_alloc), FfiConverterTypeStorageHandle.lower(storage, _bindings_ffi_default().rustbuffer_alloc));
+    }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_u64, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_u64, FfiConverterTypeProviderAuth.lift.bind(FfiConverterTypeProviderAuth), FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+  } catch (__error) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+function createStorageHandle(storage) {
+  return FfiConverterTypeStorageHandle.lift(uniffiCaller.rustCall((callStatus) => {
+    return _bindings_ffi_default().uniffi_dbx_tools_core_fn_func_create_storage_handle(FfiConverterTypeStorageAdapter.lower(storage, _bindings_ffi_default().rustbuffer_alloc), callStatus);
+  }, FfiConverterString.lift.bind(FfiConverterString)));
+}
+function credentialKey(provider, profile, scopes) {
+  const __rb = uniffiCaller.rustCall((callStatus) => {
+    return _bindings_ffi_default().uniffi_dbx_tools_core_fn_func_credential_key(FfiConverterString.lower(provider, _bindings_ffi_default().rustbuffer_alloc), FfiConverterOptionalString.lower(profile, _bindings_ffi_default().rustbuffer_alloc), FfiConverterSequenceString.lower(scopes, _bindings_ffi_default().rustbuffer_alloc), callStatus);
+  }, FfiConverterString.lift.bind(FfiConverterString));
+  try {
+    return FfiConverterString.lift(__rb);
+  } finally {
+    _bindings_ffi_default().rustbuffer_free(__rb);
+  }
+}
+function databricksCliAvailable() {
+  return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
+    return _bindings_ffi_default().uniffi_dbx_tools_core_fn_func_databricks_cli_available(callStatus);
+  }, FfiConverterString.lift.bind(FfiConverterString)));
+}
+function isDatabricksApp() {
+  return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
+    return _bindings_ffi_default().uniffi_dbx_tools_core_fn_func_is_databricks_app(callStatus);
+  }, FfiConverterString.lift.bind(FfiConverterString)));
+}
+function parseAddress(input) {
+  const __rb = uniffiCaller.rustCall((callStatus) => {
+    return _bindings_ffi_default().uniffi_dbx_tools_core_fn_func_parse_address(FfiConverterOptionalString.lower(input, _bindings_ffi_default().rustbuffer_alloc), callStatus);
+  }, FfiConverterString.lift.bind(FfiConverterString));
+  try {
+    return FfiConverterTypeParsedAddress.lift(__rb);
+  } finally {
+    _bindings_ffi_default().rustbuffer_free(__rb);
+  }
+}
+function parseResourcePath(input) {
+  const __rb = uniffiCaller.rustCall((callStatus) => {
+    return _bindings_ffi_default().uniffi_dbx_tools_core_fn_func_parse_resource_path(FfiConverterOptionalString.lower(input, _bindings_ffi_default().rustbuffer_alloc), callStatus);
+  }, FfiConverterString.lift.bind(FfiConverterString));
+  try {
+    return FfiConverterTypeParsedAddress.lift(__rb);
+  } finally {
+    _bindings_ffi_default().rustbuffer_free(__rb);
+  }
+}
+var stringConverter = (() => {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  return {
+    stringToBytes: (s) => encoder.encode(s),
+    bytesToString: (ab) => decoder.decode(ab),
+    stringByteLength: (s) => encoder.encode(s).byteLength,
+    writeStringIntoBuffer: (s, buf, offset) => {
+      const view = new Uint8Array(buf.arrayBuffer, offset, buf.arrayBuffer.byteLength - offset);
+      return encoder.encodeInto(s, view).written;
+    },
+    readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length))
+  };
+})();
+var FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+var AccessToken = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+var FfiConverterTypeAccessToken = (() => {
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        accessToken: FfiConverterString.readFromCursor(c),
+        tokenType: FfiConverterString.readFromCursor(c),
+        expiry: FfiConverterOptionalString.readFromCursor(c),
+        scopes: FfiConverterSequenceString.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterString.writeIntoCursor(value.accessToken, c);
+      FfiConverterString.writeIntoCursor(value.tokenType, c);
+      FfiConverterOptionalString.writeIntoCursor(value.expiry, c);
+      FfiConverterSequenceString.writeIntoCursor(value.scopes, c);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.accessToken) + FfiConverterString.allocationSize(value.tokenType) + FfiConverterOptionalString.allocationSize(value.expiry) + FfiConverterSequenceString.allocationSize(value.scopes);
+    }
+  }
+  return new FFIConverter;
+})();
+var AuthOptions = (() => {
+  const defaults = () => ({
+    refreshBufferSeconds: BigInt("300"),
+    lockTimeoutSeconds: BigInt("30"),
+    loginTimeoutSeconds: BigInt("3600"),
+    callbackImageSrc: undefined
+  });
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+var FfiConverterTypeAuthOptions = (() => {
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        refreshBufferSeconds: FfiConverterInt64.readFromCursor(c),
+        lockTimeoutSeconds: FfiConverterUInt64.readFromCursor(c),
+        loginTimeoutSeconds: FfiConverterUInt64.readFromCursor(c),
+        callbackImageSrc: FfiConverterOptionalString.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterInt64.writeIntoCursor(value.refreshBufferSeconds, c);
+      FfiConverterUInt64.writeIntoCursor(value.lockTimeoutSeconds, c);
+      FfiConverterUInt64.writeIntoCursor(value.loginTimeoutSeconds, c);
+      FfiConverterOptionalString.writeIntoCursor(value.callbackImageSrc, c);
+    }
+    allocationSize(value) {
+      return FfiConverterInt64.allocationSize(value.refreshBufferSeconds) + FfiConverterUInt64.allocationSize(value.lockTimeoutSeconds) + FfiConverterUInt64.allocationSize(value.loginTimeoutSeconds) + FfiConverterOptionalString.allocationSize(value.callbackImageSrc);
+    }
+  }
+  return new FFIConverter;
+})();
+var DatabricksAuthOptions = (() => {
+  const defaults = () => ({
+    profile: undefined,
+    host: undefined,
+    accountId: undefined,
+    workspaceId: undefined,
+    configFile: undefined,
+    clientId: undefined,
+    groupId: undefined,
+    authType: undefined,
+    scopes: undefined,
+    target: undefined,
+    cacheDir: undefined,
+    auth: undefined,
+    requestHeaders: undefined,
+    accessTokenHeader: undefined,
+    preferUserToMachine: true
+  });
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+var FfiConverterTypeDatabricksAuthOptions = (() => {
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        profile: FfiConverterOptionalString.readFromCursor(c),
+        host: FfiConverterOptionalString.readFromCursor(c),
+        accountId: FfiConverterOptionalString.readFromCursor(c),
+        workspaceId: FfiConverterOptionalString.readFromCursor(c),
+        configFile: FfiConverterOptionalString.readFromCursor(c),
+        clientId: FfiConverterOptionalString.readFromCursor(c),
+        groupId: FfiConverterOptionalString.readFromCursor(c),
+        authType: FfiConverterOptionalString.readFromCursor(c),
+        scopes: FfiConverterOptionalSequenceString.readFromCursor(c),
+        target: FfiConverterOptionalString.readFromCursor(c),
+        cacheDir: FfiConverterOptionalString.readFromCursor(c),
+        auth: FfiConverterOptionalTypeAuthOptions.readFromCursor(c),
+        requestHeaders: FfiConverterOptionalMapStringString.readFromCursor(c),
+        accessTokenHeader: FfiConverterOptionalString.readFromCursor(c),
+        preferUserToMachine: FfiConverterBool.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterOptionalString.writeIntoCursor(value.profile, c);
+      FfiConverterOptionalString.writeIntoCursor(value.host, c);
+      FfiConverterOptionalString.writeIntoCursor(value.accountId, c);
+      FfiConverterOptionalString.writeIntoCursor(value.workspaceId, c);
+      FfiConverterOptionalString.writeIntoCursor(value.configFile, c);
+      FfiConverterOptionalString.writeIntoCursor(value.clientId, c);
+      FfiConverterOptionalString.writeIntoCursor(value.groupId, c);
+      FfiConverterOptionalString.writeIntoCursor(value.authType, c);
+      FfiConverterOptionalSequenceString.writeIntoCursor(value.scopes, c);
+      FfiConverterOptionalString.writeIntoCursor(value.target, c);
+      FfiConverterOptionalString.writeIntoCursor(value.cacheDir, c);
+      FfiConverterOptionalTypeAuthOptions.writeIntoCursor(value.auth, c);
+      FfiConverterOptionalMapStringString.writeIntoCursor(value.requestHeaders, c);
+      FfiConverterOptionalString.writeIntoCursor(value.accessTokenHeader, c);
+      FfiConverterBool.writeIntoCursor(value.preferUserToMachine, c);
+    }
+    allocationSize(value) {
+      return FfiConverterOptionalString.allocationSize(value.profile) + FfiConverterOptionalString.allocationSize(value.host) + FfiConverterOptionalString.allocationSize(value.accountId) + FfiConverterOptionalString.allocationSize(value.workspaceId) + FfiConverterOptionalString.allocationSize(value.configFile) + FfiConverterOptionalString.allocationSize(value.clientId) + FfiConverterOptionalString.allocationSize(value.groupId) + FfiConverterOptionalString.allocationSize(value.authType) + FfiConverterOptionalSequenceString.allocationSize(value.scopes) + FfiConverterOptionalString.allocationSize(value.target) + FfiConverterOptionalString.allocationSize(value.cacheDir) + FfiConverterOptionalTypeAuthOptions.allocationSize(value.auth) + FfiConverterOptionalMapStringString.allocationSize(value.requestHeaders) + FfiConverterOptionalString.allocationSize(value.accessTokenHeader) + FfiConverterBool.allocationSize(value.preferUserToMachine);
+    }
+  }
+  return new FFIConverter;
+})();
+var Storage;
+((Storage2) => {
+  Storage2[Storage2["Auto"] = 0] = "Auto";
+  Storage2[Storage2["Memory"] = 1] = "Memory";
+  Storage2[Storage2["File"] = 2] = "File";
+})(Storage ||= {});
+var FfiConverterTypeStorage = (() => {
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return 0 /* Auto */;
+        case 2:
+          return 1 /* Memory */;
+        case 3:
+          return 2 /* File */;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case 0 /* Auto */:
+          return c.writeI32(1);
+        case 1 /* Memory */:
+          return c.writeI32(2);
+        case 2 /* File */:
+          return c.writeI32(3);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter;
+})();
+var DatabricksAuthStatus = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+var FfiConverterTypeDatabricksAuthStatus = (() => {
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        profile: FfiConverterString.readFromCursor(c),
+        host: FfiConverterString.readFromCursor(c),
+        storage: FfiConverterTypeStorage.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterString.writeIntoCursor(value.profile, c);
+      FfiConverterString.writeIntoCursor(value.host, c);
+      FfiConverterTypeStorage.writeIntoCursor(value.storage, c);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.profile) + FfiConverterString.allocationSize(value.host) + FfiConverterTypeStorage.allocationSize(value.storage);
+    }
+  }
+  return new FFIConverter;
+})();
+var SslMode;
+((SslMode2) => {
+  SslMode2[SslMode2["Require"] = 0] = "Require";
+  SslMode2[SslMode2["Disable"] = 1] = "Disable";
+  SslMode2[SslMode2["Prefer"] = 2] = "Prefer";
+})(SslMode ||= {});
+var FfiConverterTypeSslMode = (() => {
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return 0 /* Require */;
+        case 2:
+          return 1 /* Disable */;
+        case 3:
+          return 2 /* Prefer */;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case 0 /* Require */:
+          return c.writeI32(1);
+        case 1 /* Disable */:
+          return c.writeI32(2);
+        case 2 /* Prefer */:
+          return c.writeI32(3);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter;
+})();
+var ParsedAddress = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+var FfiConverterTypeParsedAddress = (() => {
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        project: FfiConverterOptionalString.readFromCursor(c),
+        branch: FfiConverterOptionalString.readFromCursor(c),
+        endpoint: FfiConverterOptionalString.readFromCursor(c),
+        endpointId: FfiConverterOptionalString.readFromCursor(c),
+        database: FfiConverterOptionalString.readFromCursor(c),
+        databaseResourceId: FfiConverterOptionalString.readFromCursor(c),
+        user: FfiConverterOptionalString.readFromCursor(c),
+        host: FfiConverterOptionalString.readFromCursor(c),
+        port: FfiConverterOptionalUInt16.readFromCursor(c),
+        sslMode: FfiConverterOptionalTypeSslMode.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterOptionalString.writeIntoCursor(value.project, c);
+      FfiConverterOptionalString.writeIntoCursor(value.branch, c);
+      FfiConverterOptionalString.writeIntoCursor(value.endpoint, c);
+      FfiConverterOptionalString.writeIntoCursor(value.endpointId, c);
+      FfiConverterOptionalString.writeIntoCursor(value.database, c);
+      FfiConverterOptionalString.writeIntoCursor(value.databaseResourceId, c);
+      FfiConverterOptionalString.writeIntoCursor(value.user, c);
+      FfiConverterOptionalString.writeIntoCursor(value.host, c);
+      FfiConverterOptionalUInt16.writeIntoCursor(value.port, c);
+      FfiConverterOptionalTypeSslMode.writeIntoCursor(value.sslMode, c);
+    }
+    allocationSize(value) {
+      return FfiConverterOptionalString.allocationSize(value.project) + FfiConverterOptionalString.allocationSize(value.branch) + FfiConverterOptionalString.allocationSize(value.endpoint) + FfiConverterOptionalString.allocationSize(value.endpointId) + FfiConverterOptionalString.allocationSize(value.database) + FfiConverterOptionalString.allocationSize(value.databaseResourceId) + FfiConverterOptionalString.allocationSize(value.user) + FfiConverterOptionalString.allocationSize(value.host) + FfiConverterOptionalUInt16.allocationSize(value.port) + FfiConverterOptionalTypeSslMode.allocationSize(value.sslMode);
+    }
+  }
+  return new FFIConverter;
+})();
+var OAuthGrant;
+((OAuthGrant2) => {
+  OAuthGrant2[OAuthGrant2["AuthorizationCode"] = 0] = "AuthorizationCode";
+  OAuthGrant2[OAuthGrant2["ClientCredentials"] = 1] = "ClientCredentials";
+})(OAuthGrant ||= {});
+var FfiConverterTypeOAuthGrant = (() => {
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return 0 /* AuthorizationCode */;
+        case 2:
+          return 1 /* ClientCredentials */;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case 0 /* AuthorizationCode */:
+          return c.writeI32(1);
+        case 1 /* ClientCredentials */:
+          return c.writeI32(2);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter;
+})();
+var FileLayout;
+((FileLayout2) => {
+  FileLayout2[FileLayout2["Single"] = 0] = "Single";
+  FileLayout2[FileLayout2["PerCredential"] = 1] = "PerCredential";
+})(FileLayout ||= {});
+var FfiConverterTypeFileLayout = (() => {
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return 0 /* Single */;
+        case 2:
+          return 1 /* PerCredential */;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value) {
+        case 0 /* Single */:
+          return c.writeI32(1);
+        case 1 /* PerCredential */:
+          return c.writeI32(2);
+      }
+    }
+    allocationSize(value) {
+      return 4;
+    }
+  }
+  return new FFIConverter;
+})();
+var ProviderOptions = (() => {
+  const defaults = () => ({
+    authorizationEndpoint: undefined,
+    clientSecret: undefined,
+    profile: undefined,
+    scopes: [],
+    grant: undefined,
+    cacheDir: undefined,
+    storage: undefined,
+    fileLayout: undefined,
+    auth: undefined
+  });
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+var FfiConverterTypeProviderOptions = (() => {
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      return {
+        provider: FfiConverterString.readFromCursor(c),
+        clientId: FfiConverterString.readFromCursor(c),
+        tokenEndpoint: FfiConverterString.readFromCursor(c),
+        authorizationEndpoint: FfiConverterOptionalString.readFromCursor(c),
+        clientSecret: FfiConverterOptionalString.readFromCursor(c),
+        profile: FfiConverterOptionalString.readFromCursor(c),
+        scopes: FfiConverterSequenceString.readFromCursor(c),
+        grant: FfiConverterOptionalTypeOAuthGrant.readFromCursor(c),
+        cacheDir: FfiConverterOptionalString.readFromCursor(c),
+        storage: FfiConverterOptionalTypeStorage.readFromCursor(c),
+        fileLayout: FfiConverterOptionalTypeFileLayout.readFromCursor(c),
+        auth: FfiConverterOptionalTypeAuthOptions.readFromCursor(c)
+      };
+    }
+    writeIntoCursor(value, c) {
+      FfiConverterString.writeIntoCursor(value.provider, c);
+      FfiConverterString.writeIntoCursor(value.clientId, c);
+      FfiConverterString.writeIntoCursor(value.tokenEndpoint, c);
+      FfiConverterOptionalString.writeIntoCursor(value.authorizationEndpoint, c);
+      FfiConverterOptionalString.writeIntoCursor(value.clientSecret, c);
+      FfiConverterOptionalString.writeIntoCursor(value.profile, c);
+      FfiConverterSequenceString.writeIntoCursor(value.scopes, c);
+      FfiConverterOptionalTypeOAuthGrant.writeIntoCursor(value.grant, c);
+      FfiConverterOptionalString.writeIntoCursor(value.cacheDir, c);
+      FfiConverterOptionalTypeStorage.writeIntoCursor(value.storage, c);
+      FfiConverterOptionalTypeFileLayout.writeIntoCursor(value.fileLayout, c);
+      FfiConverterOptionalTypeAuthOptions.writeIntoCursor(value.auth, c);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.provider) + FfiConverterString.allocationSize(value.clientId) + FfiConverterString.allocationSize(value.tokenEndpoint) + FfiConverterOptionalString.allocationSize(value.authorizationEndpoint) + FfiConverterOptionalString.allocationSize(value.clientSecret) + FfiConverterOptionalString.allocationSize(value.profile) + FfiConverterSequenceString.allocationSize(value.scopes) + FfiConverterOptionalTypeOAuthGrant.allocationSize(value.grant) + FfiConverterOptionalString.allocationSize(value.cacheDir) + FfiConverterOptionalTypeStorage.allocationSize(value.storage) + FfiConverterOptionalTypeFileLayout.allocationSize(value.fileLayout) + FfiConverterOptionalTypeAuthOptions.allocationSize(value.auth);
+    }
+  }
+  return new FFIConverter;
+})();
+var AuthError_Tags;
+((AuthError_Tags2) => {
+  AuthError_Tags2["Failure"] = "Failure";
+})(AuthError_Tags ||= {});
+var AuthError = (() => {
+
+  class Failure_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "AuthError";
+    tag = "Failure" /* Failure */;
+    inner;
+    constructor(inner) {
+      super("AuthError", "Failure");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Failure_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === "Failure" /* Failure */;
+    }
+    static hasInner(obj) {
+      return Failure_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "AuthError";
+  }
+  return Object.freeze({
+    instanceOf,
+    Failure: Failure_
+  });
+})();
+var FfiConverterTypeAuthError = (() => {
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    readFromCursor(c) {
+      switch (c.readI32()) {
+        case 1:
+          return new AuthError.Failure({ message: FfiConverterString.readFromCursor(c) });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+    writeIntoCursor(value, c) {
+      switch (value.tag) {
+        case "Failure" /* Failure */: {
+          c.writeI32(1);
+          const inner = value.inner;
+          FfiConverterString.writeIntoCursor(inner.message, c);
+          return;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case "Failure" /* Failure */: {
+          const inner = value.inner;
+          let size = 4;
+          size += FfiConverterString.allocationSize(inner.message);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+  }
+  return new FFIConverter;
+})();
+
+class PersistentAuth extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "PersistentAuth";
+  [destructorGuardSymbol];
+  [pointerLiteralSymbol];
+  constructor(pointer) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypePersistentAuthObjectFactory.bless(pointer);
+  }
+  async authorizationHeaderForUrl(requestUrl, asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_persistentauth_authorization_header_for_url(uniffiTypePersistentAuthObjectFactory.clonePointer(this), FfiConverterString.lower(requestUrl, _bindings_ffi_default().rustbuffer_alloc));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_rust_buffer, (__rb) => {
+        try {
+          return FfiConverterOptionalString.lift(__rb);
+        } finally {
+          _bindings_ffi_default().rustbuffer_free(__rb);
+        }
+      }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async challenge(asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_persistentauth_challenge(uniffiTypePersistentAuthObjectFactory.clonePointer(this));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_void, (_v) => {}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async forceRefreshToken(asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_persistentauth_force_refresh_token(uniffiTypePersistentAuthObjectFactory.clonePointer(this));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_rust_buffer, (__rb) => {
+        try {
+          return FfiConverterTypeAccessToken.lift(__rb);
+        } finally {
+          _bindings_ffi_default().rustbuffer_free(__rb);
+        }
+      }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async logout(asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_persistentauth_logout(uniffiTypePersistentAuthObjectFactory.clonePointer(this));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_void, (_v) => {}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async refreshRejectedToken(staleAccessToken, asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_persistentauth_refresh_rejected_token(uniffiTypePersistentAuthObjectFactory.clonePointer(this), FfiConverterString.lower(staleAccessToken, _bindings_ffi_default().rustbuffer_alloc));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_rust_buffer, (__rb) => {
+        try {
+          return FfiConverterTypeAccessToken.lift(__rb);
+        } finally {
+          _bindings_ffi_default().rustbuffer_free(__rb);
+        }
+      }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  status() {
+    const __rb = uniffiCaller.rustCall((callStatus) => {
+      return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_persistentauth_status(uniffiTypePersistentAuthObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterTypeDatabricksAuthStatus.lift(__rb);
+    } finally {
+      _bindings_ffi_default().rustbuffer_free(__rb);
+    }
+  }
+  async token(login = undefined, asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_persistentauth_token(uniffiTypePersistentAuthObjectFactory.clonePointer(this), FfiConverterOptionalBoolean.lower(login, _bindings_ffi_default().rustbuffer_alloc));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_rust_buffer, (__rb) => {
+        try {
+          return FfiConverterTypeAccessToken.lift(__rb);
+        } finally {
+          _bindings_ffi_default().rustbuffer_free(__rb);
+        }
+      }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypePersistentAuthObjectFactory.pointer(this);
+      uniffiTypePersistentAuthObjectFactory.freePointer(pointer);
+      uniffiTypePersistentAuthObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
+    }
+  }
+  static instanceOf(obj_) {
+    return uniffiTypePersistentAuthObjectFactory.isConcreteType(obj_);
+  }
+}
+var uniffiTypePersistentAuthObjectFactory = (() => {
+  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
+    uniffiTypePersistentAuthObjectFactory.freePointer(heldValue);
+  }) : null;
+  return {
+    create(pointer) {
+      const instance = Object.create(PersistentAuth.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "PersistentAuth";
+      return instance;
+    },
+    bless(p) {
+      const ptr = {
+        p,
+        markDestroyed: () => {
+          return;
+        }
+      };
+      if (registry) {
+        registry.register(ptr, p, ptr);
+      }
+      return ptr;
+    },
+    unbless(ptr_) {
+      if (registry) {
+        registry.unregister(ptr_);
+      }
+    },
+    pointer(obj_) {
+      if (obj_[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer;
+      }
+      return obj_[pointerLiteralSymbol];
+    },
+    clonePointer(obj_) {
+      const pointer = this.pointer(obj_);
+      return uniffiCaller.rustCall((callStatus) => _bindings_ffi_default().uniffi_dbx_tools_core_fn_clone_persistentauth(pointer, callStatus), FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall((callStatus) => _bindings_ffi_default().uniffi_dbx_tools_core_fn_free_persistentauth(pointer, callStatus), FfiConverterString.lift);
+    },
+    isConcreteType(obj_) {
+      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "PersistentAuth";
+    }
+  };
+})();
+var FfiConverterTypePersistentAuth = new FfiConverterObject(uniffiTypePersistentAuthObjectFactory);
+
+class ProviderAuth extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "ProviderAuth";
+  [destructorGuardSymbol];
+  [pointerLiteralSymbol];
+  constructor(pointer) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeProviderAuthObjectFactory.bless(pointer);
+  }
+  async forceRefreshToken(asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_providerauth_force_refresh_token(uniffiTypeProviderAuthObjectFactory.clonePointer(this));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_rust_buffer, (__rb) => {
+        try {
+          return FfiConverterTypeAccessToken.lift(__rb);
+        } finally {
+          _bindings_ffi_default().rustbuffer_free(__rb);
+        }
+      }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async logout(asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_providerauth_logout(uniffiTypeProviderAuthObjectFactory.clonePointer(this));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_void, (_v) => {}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async refreshRejectedToken(staleAccessToken, asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_providerauth_refresh_rejected_token(uniffiTypeProviderAuthObjectFactory.clonePointer(this), FfiConverterString.lower(staleAccessToken, _bindings_ffi_default().rustbuffer_alloc));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_rust_buffer, (__rb) => {
+        try {
+          return FfiConverterTypeAccessToken.lift(__rb);
+        } finally {
+          _bindings_ffi_default().rustbuffer_free(__rb);
+        }
+      }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async token(login = undefined, asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_providerauth_token(uniffiTypeProviderAuthObjectFactory.clonePointer(this), FfiConverterOptionalBoolean.lower(login, _bindings_ffi_default().rustbuffer_alloc));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_rust_buffer, (__rb) => {
+        try {
+          return FfiConverterTypeAccessToken.lift(__rb);
+        } finally {
+          _bindings_ffi_default().rustbuffer_free(__rb);
+        }
+      }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeProviderAuthObjectFactory.pointer(this);
+      uniffiTypeProviderAuthObjectFactory.freePointer(pointer);
+      uniffiTypeProviderAuthObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
+    }
+  }
+  static instanceOf(obj_) {
+    return uniffiTypeProviderAuthObjectFactory.isConcreteType(obj_);
+  }
+}
+var uniffiTypeProviderAuthObjectFactory = (() => {
+  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
+    uniffiTypeProviderAuthObjectFactory.freePointer(heldValue);
+  }) : null;
+  return {
+    create(pointer) {
+      const instance = Object.create(ProviderAuth.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "ProviderAuth";
+      return instance;
+    },
+    bless(p) {
+      const ptr = {
+        p,
+        markDestroyed: () => {
+          return;
+        }
+      };
+      if (registry) {
+        registry.register(ptr, p, ptr);
+      }
+      return ptr;
+    },
+    unbless(ptr_) {
+      if (registry) {
+        registry.unregister(ptr_);
+      }
+    },
+    pointer(obj_) {
+      if (obj_[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer;
+      }
+      return obj_[pointerLiteralSymbol];
+    },
+    clonePointer(obj_) {
+      const pointer = this.pointer(obj_);
+      return uniffiCaller.rustCall((callStatus) => _bindings_ffi_default().uniffi_dbx_tools_core_fn_clone_providerauth(pointer, callStatus), FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall((callStatus) => _bindings_ffi_default().uniffi_dbx_tools_core_fn_free_providerauth(pointer, callStatus), FfiConverterString.lift);
+    },
+    isConcreteType(obj_) {
+      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "ProviderAuth";
+    }
+  };
+})();
+var FfiConverterTypeProviderAuth = new FfiConverterObject(uniffiTypeProviderAuthObjectFactory);
+
+class StorageAdapterImpl extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "StorageAdapterImpl";
+  [destructorGuardSymbol];
+  [pointerLiteralSymbol];
+  constructor(pointer) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeStorageAdapterImplObjectFactory.bless(pointer);
+  }
+  async load(profile, asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_storageadapter_load(uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this), FfiConverterString.lower(profile, _bindings_ffi_default().rustbuffer_alloc));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_rust_buffer, (__rb) => {
+        try {
+          return FfiConverterOptionalString.lift(__rb);
+        } finally {
+          _bindings_ffi_default().rustbuffer_free(__rb);
+        }
+      }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async prepareWrite(asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_storageadapter_prepare_write(uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_void, (_v) => {}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async save(profile, token, asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_storageadapter_save(uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this), FfiConverterString.lower(profile, _bindings_ffi_default().rustbuffer_alloc), FfiConverterString.lower(token, _bindings_ffi_default().rustbuffer_alloc));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_void, (_v) => {}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async remove(profile, asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_storageadapter_remove(uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this), FfiConverterString.lower(profile, _bindings_ffi_default().rustbuffer_alloc));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_void, (_v) => {}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async acquireLock(profile, timeoutMillis, asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_storageadapter_acquire_lock(uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this), FfiConverterString.lower(profile, _bindings_ffi_default().rustbuffer_alloc), FfiConverterUInt64.lower(timeoutMillis, _bindings_ffi_default().rustbuffer_alloc));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_rust_buffer, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_rust_buffer, (__rb) => {
+        try {
+          return FfiConverterString.lift(__rb);
+        } finally {
+          _bindings_ffi_default().rustbuffer_free(__rb);
+        }
+      }, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  async releaseLock(lease, asyncOpts_) {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(uniffiCaller, () => {
+        return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_storageadapter_release_lock(uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this), FfiConverterString.lower(lease, _bindings_ffi_default().rustbuffer_alloc));
+      }, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_poll_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_cancel_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_complete_void, _bindings_ffi_default().ffi_dbx_tools_core_rust_future_free_void, (_v) => {}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError));
+    } catch (__error) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+  name() {
+    const __rb = uniffiCaller.rustCall((callStatus) => {
+      return _bindings_ffi_default().uniffi_dbx_tools_core_fn_method_storageadapter_name(uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterString.lift(__rb);
+    } finally {
+      _bindings_ffi_default().rustbuffer_free(__rb);
+    }
+  }
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeStorageAdapterImplObjectFactory.pointer(this);
+      uniffiTypeStorageAdapterImplObjectFactory.freePointer(pointer);
+      uniffiTypeStorageAdapterImplObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
+    }
+  }
+  static instanceOf(obj_) {
+    return uniffiTypeStorageAdapterImplObjectFactory.isConcreteType(obj_);
+  }
+}
+var uniffiTypeStorageAdapterImplObjectFactory = (() => {
+  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
+    uniffiTypeStorageAdapterImplObjectFactory.freePointer(heldValue);
+  }) : null;
+  return {
+    create(pointer) {
+      const instance = Object.create(StorageAdapterImpl.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "StorageAdapterImpl";
+      return instance;
+    },
+    bless(p) {
+      const ptr = {
+        p,
+        markDestroyed: () => {
+          return;
+        }
+      };
+      if (registry) {
+        registry.register(ptr, p, ptr);
+      }
+      return ptr;
+    },
+    unbless(ptr_) {
+      if (registry) {
+        registry.unregister(ptr_);
+      }
+    },
+    pointer(obj_) {
+      if (obj_[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer;
+      }
+      return obj_[pointerLiteralSymbol];
+    },
+    clonePointer(obj_) {
+      const pointer = this.pointer(obj_);
+      return uniffiCaller.rustCall((callStatus) => _bindings_ffi_default().uniffi_dbx_tools_core_fn_clone_storageadapter(pointer, callStatus), FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall((callStatus) => _bindings_ffi_default().uniffi_dbx_tools_core_fn_free_storageadapter(pointer, callStatus), FfiConverterString.lift);
+    },
+    isConcreteType(obj_) {
+      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "StorageAdapterImpl";
+    }
+  };
+})();
+var FfiConverterTypeStorageAdapter = new FfiConverterObjectWithCallbacks(uniffiTypeStorageAdapterImplObjectFactory);
+var uniffiCallbackInterfaceStorageAdapter = {
+  vtable: {
+    load: (uniffiHandle, profile, uniffiFutureCallback, uniffiCallbackData) => {
+      const uniffiMakeCall = async (signal) => {
+        const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+        return await jsCallback.load(FfiConverterString.lift(profile), { signal });
+      };
+      const uniffiHandleSuccess = (returnValue) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          return_value: FfiConverterOptionalString.lower(returnValue, _bindings_ffi_default().rustbuffer_alloc),
+          call_status: uniffiCaller.createCallStatus()
+        });
+      };
+      const uniffiHandleError = (code, errorBuf) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          return_value: new Uint8Array(0),
+          call_status: uniffiCaller.createErrorStatus(code, errorBuf)
+        });
+      };
+      const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, AuthError.instanceOf, FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError), FfiConverterString.lower.bind(FfiConverterString), _bindings_ffi_default().rustbuffer_alloc);
+      return uniffiForeignFuture;
+    },
+    prepare_write: (uniffiHandle, uniffiFutureCallback, uniffiCallbackData) => {
+      const uniffiMakeCall = async (signal) => {
+        const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+        return await jsCallback.prepareWrite({ signal });
+      };
+      const uniffiHandleSuccess = (returnValue) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          call_status: uniffiCaller.createCallStatus()
+        });
+      };
+      const uniffiHandleError = (code, errorBuf) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          call_status: uniffiCaller.createErrorStatus(code, errorBuf)
+        });
+      };
+      const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, AuthError.instanceOf, FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError), FfiConverterString.lower.bind(FfiConverterString), _bindings_ffi_default().rustbuffer_alloc);
+      return uniffiForeignFuture;
+    },
+    save: (uniffiHandle, profile, token, uniffiFutureCallback, uniffiCallbackData) => {
+      const uniffiMakeCall = async (signal) => {
+        const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+        return await jsCallback.save(FfiConverterString.lift(profile), FfiConverterString.lift(token), { signal });
+      };
+      const uniffiHandleSuccess = (returnValue) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          call_status: uniffiCaller.createCallStatus()
+        });
+      };
+      const uniffiHandleError = (code, errorBuf) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          call_status: uniffiCaller.createErrorStatus(code, errorBuf)
+        });
+      };
+      const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, AuthError.instanceOf, FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError), FfiConverterString.lower.bind(FfiConverterString), _bindings_ffi_default().rustbuffer_alloc);
+      return uniffiForeignFuture;
+    },
+    remove: (uniffiHandle, profile, uniffiFutureCallback, uniffiCallbackData) => {
+      const uniffiMakeCall = async (signal) => {
+        const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+        return await jsCallback.remove(FfiConverterString.lift(profile), { signal });
+      };
+      const uniffiHandleSuccess = (returnValue) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          call_status: uniffiCaller.createCallStatus()
+        });
+      };
+      const uniffiHandleError = (code, errorBuf) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          call_status: uniffiCaller.createErrorStatus(code, errorBuf)
+        });
+      };
+      const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, AuthError.instanceOf, FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError), FfiConverterString.lower.bind(FfiConverterString), _bindings_ffi_default().rustbuffer_alloc);
+      return uniffiForeignFuture;
+    },
+    acquire_lock: (uniffiHandle, profile, timeoutMillis, uniffiFutureCallback, uniffiCallbackData) => {
+      const uniffiMakeCall = async (signal) => {
+        const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+        return await jsCallback.acquireLock(FfiConverterString.lift(profile), FfiConverterUInt64.lift(timeoutMillis), { signal });
+      };
+      const uniffiHandleSuccess = (returnValue) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          return_value: FfiConverterString.lower(returnValue, _bindings_ffi_default().rustbuffer_alloc),
+          call_status: uniffiCaller.createCallStatus()
+        });
+      };
+      const uniffiHandleError = (code, errorBuf) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          return_value: new Uint8Array(0),
+          call_status: uniffiCaller.createErrorStatus(code, errorBuf)
+        });
+      };
+      const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, AuthError.instanceOf, FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError), FfiConverterString.lower.bind(FfiConverterString), _bindings_ffi_default().rustbuffer_alloc);
+      return uniffiForeignFuture;
+    },
+    release_lock: (uniffiHandle, lease, uniffiFutureCallback, uniffiCallbackData) => {
+      const uniffiMakeCall = async (signal) => {
+        const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+        return await jsCallback.releaseLock(FfiConverterString.lift(lease), { signal });
+      };
+      const uniffiHandleSuccess = (returnValue) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          call_status: uniffiCaller.createCallStatus()
+        });
+      };
+      const uniffiHandleError = (code, errorBuf) => {
+        uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
+          call_status: uniffiCaller.createErrorStatus(code, errorBuf)
+        });
+      };
+      const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, AuthError.instanceOf, FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError), FfiConverterString.lower.bind(FfiConverterString), _bindings_ffi_default().rustbuffer_alloc);
+      return uniffiForeignFuture;
+    },
+    name: (uniffiHandle) => {
+      const uniffiMakeCall = () => {
+        const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+        return jsCallback.name();
+      };
+      const uniffiResult = UniffiResult.ready();
+      const uniffiHandleSuccess = (obj) => {
+        UniffiResult.writeSuccess(uniffiResult, FfiConverterString.lower(obj, _bindings_ffi_default().rustbuffer_alloc));
+      };
+      const uniffiHandleError = (code, errBuf) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCall(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, FfiConverterString.lower.bind(FfiConverterString), _bindings_ffi_default().rustbuffer_alloc);
+      return uniffiResult;
+    },
+    uniffi_free: (uniffiHandle) => {
+      FfiConverterTypeStorageAdapter.drop(uniffiHandle);
+    },
+    uniffi_clone: (uniffiHandle) => {
+      return FfiConverterTypeStorageAdapter.clone(uniffiHandle);
+    }
+  },
+  register: () => {
+    _bindings_ffi_default().uniffi_dbx_tools_core_fn_init_callback_vtable_storageadapter(uniffiCallbackInterfaceStorageAdapter.vtable);
+  }
+};
+
+class StorageHandle extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "StorageHandle";
+  [destructorGuardSymbol];
+  [pointerLiteralSymbol];
+  constructor(pointer) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeStorageHandleObjectFactory.bless(pointer);
+  }
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeStorageHandleObjectFactory.pointer(this);
+      uniffiTypeStorageHandleObjectFactory.freePointer(pointer);
+      uniffiTypeStorageHandleObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
+    }
+  }
+  static instanceOf(obj_) {
+    return uniffiTypeStorageHandleObjectFactory.isConcreteType(obj_);
+  }
+}
+var uniffiTypeStorageHandleObjectFactory = (() => {
+  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
+    uniffiTypeStorageHandleObjectFactory.freePointer(heldValue);
+  }) : null;
+  return {
+    create(pointer) {
+      const instance = Object.create(StorageHandle.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "StorageHandle";
+      return instance;
+    },
+    bless(p) {
+      const ptr = {
+        p,
+        markDestroyed: () => {
+          return;
+        }
+      };
+      if (registry) {
+        registry.register(ptr, p, ptr);
+      }
+      return ptr;
+    },
+    unbless(ptr_) {
+      if (registry) {
+        registry.unregister(ptr_);
+      }
+    },
+    pointer(obj_) {
+      if (obj_[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer;
+      }
+      return obj_[pointerLiteralSymbol];
+    },
+    clonePointer(obj_) {
+      const pointer = this.pointer(obj_);
+      return uniffiCaller.rustCall((callStatus) => _bindings_ffi_default().uniffi_dbx_tools_core_fn_clone_storagehandle(pointer, callStatus), FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall((callStatus) => _bindings_ffi_default().uniffi_dbx_tools_core_fn_free_storagehandle(pointer, callStatus), FfiConverterString.lift);
+    },
+    isConcreteType(obj_) {
+      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "StorageHandle";
+    }
+  };
+})();
+var FfiConverterTypeStorageHandle = new FfiConverterObject(uniffiTypeStorageHandleObjectFactory);
+var FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+var FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
+var FfiConverterOptionalSequenceString = new FfiConverterOptional(FfiConverterSequenceString);
+var FfiConverterOptionalTypeAuthOptions = new FfiConverterOptional(FfiConverterTypeAuthOptions);
+var FfiConverterMapStringString = new FfiConverterMap(FfiConverterString, FfiConverterString);
+var FfiConverterOptionalMapStringString = new FfiConverterOptional(FfiConverterMapStringString);
+var FfiConverterOptionalUInt16 = new FfiConverterOptional(FfiConverterUInt16);
+var FfiConverterOptionalTypeSslMode = new FfiConverterOptional(FfiConverterTypeSslMode);
+var FfiConverterOptionalTypeOAuthGrant = new FfiConverterOptional(FfiConverterTypeOAuthGrant);
+var FfiConverterOptionalTypeStorage = new FfiConverterOptional(FfiConverterTypeStorage);
+var FfiConverterOptionalTypeFileLayout = new FfiConverterOptional(FfiConverterTypeFileLayout);
+var FfiConverterOptionalBoolean = new FfiConverterOptional(FfiConverterBool);
+function uniffiEnsureInitialized() {
+  const bindingsContractVersion = 30;
+  const scaffoldingContractVersion = _bindings_ffi_default().ffi_dbx_tools_core_uniffi_contract_version();
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_func_canonical_scopes() !== 62077) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_canonical_scopes");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_func_create_persistent_auth() !== 18830) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_create_persistent_auth");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_func_create_persistent_auth_with_storage() !== 22339) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_create_persistent_auth_with_storage");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_func_create_provider_auth() !== 4445) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_create_provider_auth");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_func_create_provider_auth_with_storage() !== 46166) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_create_provider_auth_with_storage");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_func_create_storage_handle() !== 15610) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_create_storage_handle");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_func_credential_key() !== 36458) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_credential_key");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_func_databricks_cli_available() !== 27788) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_databricks_cli_available");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_func_is_databricks_app() !== 52373) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_is_databricks_app");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_func_parse_address() !== 9538) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_parse_address");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_func_parse_resource_path() !== 62884) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_parse_resource_path");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_persistentauth_authorization_header_for_url() !== 39071) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_persistentauth_authorization_header_for_url");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_persistentauth_challenge() !== 32194) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_persistentauth_challenge");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_persistentauth_force_refresh_token() !== 34839) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_persistentauth_force_refresh_token");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_persistentauth_logout() !== 22550) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_persistentauth_logout");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_persistentauth_refresh_rejected_token() !== 25961) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_persistentauth_refresh_rejected_token");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_persistentauth_status() !== 3099) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_persistentauth_status");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_persistentauth_token() !== 38242) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_persistentauth_token");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_providerauth_force_refresh_token() !== 12705) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_providerauth_force_refresh_token");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_providerauth_logout() !== 64726) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_providerauth_logout");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_providerauth_refresh_rejected_token() !== 47589) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_providerauth_refresh_rejected_token");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_providerauth_token() !== 37517) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_providerauth_token");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_storageadapter_load() !== 54668) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_load");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_storageadapter_prepare_write() !== 45067) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_prepare_write");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_storageadapter_save() !== 63958) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_save");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_storageadapter_remove() !== 16750) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_remove");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_storageadapter_acquire_lock() !== 64986) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_acquire_lock");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_storageadapter_release_lock() !== 64198) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_release_lock");
+  }
+  if (_bindings_ffi_default().uniffi_dbx_tools_core_checksum_method_storageadapter_name() !== 6080) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_name");
+  }
+  uniffiCallbackInterfaceStorageAdapter.register();
+}
+var _bindings_default = Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeAccessToken,
+    FfiConverterTypeAuthError,
+    FfiConverterTypeAuthOptions,
+    FfiConverterTypeDatabricksAuthOptions,
+    FfiConverterTypeDatabricksAuthStatus,
+    FfiConverterTypeFileLayout,
+    FfiConverterTypeOAuthGrant,
+    FfiConverterTypeParsedAddress,
+    FfiConverterTypePersistentAuth,
+    FfiConverterTypeProviderAuth,
+    FfiConverterTypeProviderOptions,
+    FfiConverterTypeSslMode,
+    FfiConverterTypeStorage,
+    FfiConverterTypeStorageAdapter,
+    FfiConverterTypeStorageHandle
+  }
+});
+// src/bindings.ts
+_bindings_default.initialize();
+async function uniffiInitAsync() {}
+
+// index.ts
+var PACKAGE_IDENTIFIER = "@dbx-tools/core-rs";
+var PACKAGE_VERSION = "0.6.188";
+export {
+  _bindings_default as uniffiModule,
+  uniffiInitAsync,
+  parseResourcePath,
+  parseAddress,
+  isDatabricksApp,
+  databricksCliAvailable,
+  credentialKey,
+  createStorageHandle,
+  createProviderAuthWithStorage,
+  createProviderAuth,
+  createPersistentAuthWithStorage,
+  createPersistentAuth,
+  canonicalScopes,
+  StorageHandle,
+  StorageAdapterImpl,
+  Storage,
+  SslMode,
+  ProviderOptions,
+  ProviderAuth,
+  PersistentAuth,
+  ParsedAddress,
+  PACKAGE_VERSION,
+  PACKAGE_IDENTIFIER,
+  OAuthGrant,
+  FileLayout,
+  DatabricksAuthStatus,
+  DatabricksAuthOptions,
+  AuthOptions,
+  AuthError_Tags,
+  AuthError,
+  AccessToken
+};