@dbx-tools/core-rs 0.6.188

package/src/_bindings.ts

@@ -0,0 +1,2794 @@
+// GENERATED by UniFFI binding generation - DO NOT EDIT.
+// Regenerated from the dbx-tools-core Rust exports.
+// Hand edits are overwritten on the next watch; this file is read-only.
+
+/* eslint-disable */
+// @ts-nocheck
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+import nativeModule from "./_bindings-ffi.ts";
+import { type UniffiRustFutureContinuationCallback, type UniffiForeignFutureDroppedCallback, type UniffiForeignFutureDroppedCallbackStruct, type UniffiForeignFutureResultRustBuffer, type UniffiForeignFutureCompleterustBuffer, type UniffiForeignFutureResultVoid, type UniffiForeignFutureCompletevoid, type UniffiVTableCallbackInterfaceDbxToolsCoreStorageAdapter,
+} from "./_bindings-ffi.ts";
+import { type FfiConverter, type UniffiByteArray, type UniffiGcObject, type UniffiHandle, type UniffiObjectFactory, type UniffiReferenceHolder, type UniffiRustCallStatus, AbstractFfiConverterByteArray, Cursor, FfiConverterArray, FfiConverterBool, FfiConverterInt64, FfiConverterMap, FfiConverterObject, FfiConverterObjectWithCallbacks, FfiConverterOptional, FfiConverterUInt16, FfiConverterUInt64, FfiConverterUInt8, RustBuffer, UniffiAbstractObject, UniffiEnum, UniffiError, UniffiInternalError, UniffiResult, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTraitInterfaceCall, uniffiTraitInterfaceCallAsyncWithError, uniffiTypeNameSymbol, variantOrdinalSymbol,
+} from "@ubjs/core";
+const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
+
+const uniffiIsDebug =
+  // @ts-ignore -- The process global might not be defined
+  typeof process !== "object" ||
+  // @ts-ignore -- The process global might not be defined
+  process?.env?.NODE_ENV !== "production" ||
+  false;
+
+// Public interface members begin here.
+
+/**
+ * Trim, sort, and deduplicate scopes for requests and credential identities.
+ */
+export function canonicalScopes(scopes: Array<string>): Array<string> {
+    const __rb: Uint8Array = uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_core_fn_func_canonical_scopes(
+        FfiConverterSequenceString.lower(scopes, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    try {
+        return FfiConverterSequenceString.lift(__rb);
+    } finally {
+        nativeModule().rustbuffer_free(__rb);
+    }
+    }
+
+/**
+ * Resolve a Databricks profile and open built-in credential storage.
+ */
+export async function createPersistentAuth(options: DatabricksAuthOptions, storage: Storage | undefined = undefined, asyncOpts_?: { signal: AbortSignal }): Promise<PersistentAuthLike> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_func_create_persistent_auth(FfiConverterTypeDatabricksAuthOptions.lower(options, nativeModule().rustbuffer_alloc),FfiConverterOptionalTypeStorage.lower(storage, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_u64,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_u64,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_u64,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_u64,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypePersistentAuth.lift.bind(FfiConverterTypePersistentAuth),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Resolve a Databricks profile using a shared owning-library storage handle.
+ */
+export async function createPersistentAuthWithStorage(options: DatabricksAuthOptions, storage: StorageHandleLike, asyncOpts_?: { signal: AbortSignal }): Promise<PersistentAuthLike> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_func_create_persistent_auth_with_storage(FfiConverterTypeDatabricksAuthOptions.lower(options, nativeModule().rustbuffer_alloc),FfiConverterTypeStorageHandle.lower(storage, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_u64,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_u64,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_u64,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_u64,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypePersistentAuth.lift.bind(FfiConverterTypePersistentAuth),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Construct a provider with built-in persistent storage and shared lifecycle defaults.
+ */
+export async function createProviderAuth(options: ProviderOptions, asyncOpts_?: { signal: AbortSignal }): Promise<ProviderAuthLike> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_func_create_provider_auth(FfiConverterTypeProviderOptions.lower(options, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_u64,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_u64,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_u64,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_u64,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeProviderAuth.lift.bind(FfiConverterTypeProviderAuth),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Construct a provider from the same owning-library storage handle used by Databricks auth.
+ */
+export async function createProviderAuthWithStorage(options: ProviderOptions, storage: StorageHandleLike, asyncOpts_?: { signal: AbortSignal }): Promise<ProviderAuthLike> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_func_create_provider_auth_with_storage(FfiConverterTypeProviderOptions.lower(options, nativeModule().rustbuffer_alloc),FfiConverterTypeStorageHandle.lower(storage, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_u64,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_u64,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_u64,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_u64,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeProviderAuth.lift.bind(FfiConverterTypeProviderAuth),
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Wrap custom storage before passing it into another provider's native library.
+ */
+export function createStorageHandle(storage: StorageAdapter): StorageHandleLike {
+    return FfiConverterTypeStorageHandle.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_core_fn_func_create_storage_handle(
+        FfiConverterTypeStorageAdapter.lower(storage, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+
+/**
+ * Derive a stable provider/profile/scope-set identity without storing raw scopes in the key.
+ */
+export function credentialKey(provider: string, profile: string | undefined, scopes: Array<string>): string {
+    const __rb: Uint8Array = uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_core_fn_func_credential_key(
+        FfiConverterString.lower(provider, nativeModule().rustbuffer_alloc),
+        FfiConverterOptionalString.lower(profile, nativeModule().rustbuffer_alloc),
+        FfiConverterSequenceString.lower(scopes, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    try {
+        return FfiConverterString.lift(__rb);
+    } finally {
+        nativeModule().rustbuffer_free(__rb);
+    }
+    }
+
+/**
+ * Whether `databricks auth --help` succeeds in this process environment.
+ */
+export function databricksCliAvailable(): boolean {
+    return FfiConverterBool.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_core_fn_func_databricks_cli_available(
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+
+/**
+ * Detect whether the current process is running as a Databricks App.
+ */
+export function isDatabricksApp(): boolean {
+    return FfiConverterBool.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_core_fn_func_is_databricks_app(
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+
+/**
+ * Parse a PostgreSQL URL, Lakebase resource path, hostname, or project id.
+ */
+export function parseAddress(input: string | undefined): ParsedAddress {
+    const __rb: Uint8Array = uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_core_fn_func_parse_address(
+        FfiConverterOptionalString.lower(input, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    try {
+        return FfiConverterTypeParsedAddress.lift(__rb);
+    } finally {
+        nativeModule().rustbuffer_free(__rb);
+    }
+    }
+
+/**
+ * Parse a canonical Lakebase `projects/...` resource path.
+ */
+export function parseResourcePath(input: string | undefined): ParsedAddress {
+    const __rb: Uint8Array = uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_core_fn_func_parse_resource_path(
+        FfiConverterOptionalString.lower(input, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    try {
+        return FfiConverterTypeParsedAddress.lift(__rb);
+    } finally {
+        nativeModule().rustbuffer_free(__rb);
+    }
+    }
+
+const stringConverter = (() => {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        stringToBytes: (s: string) => encoder.encode(s),
+        bytesToString: (ab: UniffiByteArray) => decoder.decode(ab),
+        stringByteLength: (s: string) => encoder.encode(s).byteLength,
+        writeStringIntoBuffer: (s: string, buf: any, offset: number): number => {
+            const view = new Uint8Array(
+                buf.arrayBuffer,
+                offset,
+                buf.arrayBuffer.byteLength - offset,
+            );
+            return encoder.encodeInto(s, view).written;
+        },
+        readStringFromBuffer: (buf: any, offset: number, length: number): string =>
+            decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length)),
+    };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+/**
+ * Public credential result; deliberately excludes the refresh token.
+ */
+export type AccessToken = {
+    /**
+     * Access token secret presented to protected resources.
+     */
+    accessToken: string,
+    /**
+     * OAuth token type returned by the provider.
+     */
+    tokenType: string,
+    /**
+     * Formatted absolute expiry, when known.
+     */
+    expiry?: string,
+    /**
+     * Scopes granted to the credential.
+     */
+    scopes: Array<string>
+}
+
+/**
+ * Generated factory for {@link AccessToken} record objects.
+ */
+export const AccessToken = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<AccessToken, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<AccessToken>,
+    });
+})();
+
+const FfiConverterTypeAccessToken = (() => {
+    type TypeName = AccessToken;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                accessToken: FfiConverterString.readFromCursor(c),
+                tokenType: FfiConverterString.readFromCursor(c),
+                expiry: FfiConverterOptionalString.readFromCursor(c),
+                scopes: FfiConverterSequenceString.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterString.writeIntoCursor(value.accessToken, c);
+            FfiConverterString.writeIntoCursor(value.tokenType, c);
+            FfiConverterOptionalString.writeIntoCursor(value.expiry, c);
+            FfiConverterSequenceString.writeIntoCursor(value.scopes, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.accessToken) +
+             FfiConverterString.allocationSize(value.tokenType) +
+             FfiConverterOptionalString.allocationSize(value.expiry) +
+             FfiConverterSequenceString.allocationSize(value.scopes);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Shared lifecycle configuration embedded by every provider's binding options.
+ */
+export type AuthOptions = {
+    /**
+     * Renew credentials this many seconds before expiry; negative values are allowed.
+     */
+    refreshBufferSeconds: bigint,
+    /**
+     * Maximum time spent waiting for the credential store's refresh lock.
+     */
+    lockTimeoutSeconds: bigint,
+    /**
+     * Maximum time allowed for a new interactive login.
+     */
+    loginTimeoutSeconds: bigint,
+    /**
+     * Logo URL or data URI displayed by the browser callback page.
+     */
+    callbackImageSrc?: string
+}
+
+/**
+ * Generated factory for {@link AuthOptions} record objects.
+ */
+export const AuthOptions = (() => {
+    const defaults = () => ({
+        refreshBufferSeconds: BigInt("300"),
+        lockTimeoutSeconds: BigInt("30"),
+        loginTimeoutSeconds: BigInt("3600"),
+        callbackImageSrc: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<AuthOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<AuthOptions>,
+    });
+})();
+
+const FfiConverterTypeAuthOptions = (() => {
+    type TypeName = AuthOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                refreshBufferSeconds: FfiConverterInt64.readFromCursor(c),
+                lockTimeoutSeconds: FfiConverterUInt64.readFromCursor(c),
+                loginTimeoutSeconds: FfiConverterUInt64.readFromCursor(c),
+                callbackImageSrc: FfiConverterOptionalString.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterInt64.writeIntoCursor(value.refreshBufferSeconds, c);
+            FfiConverterUInt64.writeIntoCursor(value.lockTimeoutSeconds, c);
+            FfiConverterUInt64.writeIntoCursor(value.loginTimeoutSeconds, c);
+            FfiConverterOptionalString.writeIntoCursor(value.callbackImageSrc, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterInt64.allocationSize(value.refreshBufferSeconds) +
+             FfiConverterUInt64.allocationSize(value.lockTimeoutSeconds) +
+             FfiConverterUInt64.allocationSize(value.loginTimeoutSeconds) +
+             FfiConverterOptionalString.allocationSize(value.callbackImageSrc);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Configuration shared by the generated Node and Python auth bindings.
+ */
+export type DatabricksAuthOptions = {
+    /**
+     * Explicit profile name; explicit choices are never remapped to another profile.
+     */
+    profile?: string,
+    /**
+     * Override the workspace or account host.
+     */
+    host?: string,
+    /**
+     * Account identifier for account-scoped authentication.
+     */
+    accountId?: string,
+    /**
+     * Workspace identifier for unified authentication.
+     */
+    workspaceId?: string,
+    /**
+     * Override the Databricks CLI configuration file.
+     */
+    configFile?: string,
+    /**
+     * Override the OAuth application identifier.
+     */
+    clientId?: string,
+    /**
+     * Optional group role requested by M2M token generation.
+     */
+    groupId?: string,
+    /**
+     * Explicit Databricks authentication strategy.
+     */
+    authType?: string,
+    /**
+     * Override profile scopes; omission preserves profile/default scope resolution.
+     */
+    scopes?: Array<string>,
+    /**
+     * Target kind: workspace, account, or unified.
+     */
+    target?: string,
+    /**
+     * Override the directory containing the shared CLI token cache.
+     */
+    cacheDir?: string,
+    /**
+     * Shared lifecycle configuration; omission uses `AuthOptions::default()`.
+     */
+    auth?: AuthOptions,
+    /**
+     * Request headers available to request-scoped authentication.
+     */
+    requestHeaders?: Map<string, string>,
+    /**
+     * Header selected from `request_headers`; defaults to `authorization`.
+     */
+    accessTokenHeader?: string,
+    /**
+     * Whether implicit M2M defaults should select one matching U2M profile.
+     */
+    preferUserToMachine: boolean
+}
+
+/**
+ * Generated factory for {@link DatabricksAuthOptions} record objects.
+ */
+export const 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<DatabricksAuthOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<DatabricksAuthOptions>,
+    });
+})();
+
+const FfiConverterTypeDatabricksAuthOptions = (() => {
+    type TypeName = DatabricksAuthOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            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: TypeName, c: Cursor): void {
+            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: TypeName): number {
+            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();
+})();
+
+/**
+ * Built-in credential storage backend.
+ */
+export enum Storage {
+    /**
+     * Select file storage.
+     */
+    Auto,
+    /**
+     * Keep credentials in process memory.
+     */
+    Memory,
+    /**
+     * Persist credentials in the configured directory.
+     */
+    File
+}
+
+const FfiConverterTypeStorage = (() => {
+    type TypeName = Storage;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return Storage.Auto;
+                case 2: return Storage.Memory;
+                case 3: return Storage.File;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case Storage.Auto: return c.writeI32(1);
+                case Storage.Memory: return c.writeI32(2);
+                case Storage.File: return c.writeI32(3);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * Resolved Databricks identity and active storage backend.
+ */
+export type DatabricksAuthStatus = {
+    /**
+     * Resolved Databricks CLI profile name.
+     */
+    profile: string,
+    /**
+     * Resolved workspace or accounts host.
+     */
+    host: string,
+    /**
+     * Credential storage backend used by the authentication session.
+     */
+    storage: Storage
+}
+
+/**
+ * Generated factory for {@link DatabricksAuthStatus} record objects.
+ */
+export const DatabricksAuthStatus = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<DatabricksAuthStatus, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<DatabricksAuthStatus>,
+    });
+})();
+
+const FfiConverterTypeDatabricksAuthStatus = (() => {
+    type TypeName = DatabricksAuthStatus;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                profile: FfiConverterString.readFromCursor(c),
+                host: FfiConverterString.readFromCursor(c),
+                storage: FfiConverterTypeStorage.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterString.writeIntoCursor(value.profile, c);
+            FfiConverterString.writeIntoCursor(value.host, c);
+            FfiConverterTypeStorage.writeIntoCursor(value.storage, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterString.allocationSize(value.profile) +
+             FfiConverterString.allocationSize(value.host) +
+             FfiConverterTypeStorage.allocationSize(value.storage);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * PostgreSQL TLS modes recognized in Lakebase connection URLs.
+ */
+export enum SslMode {
+    /**
+     * Require a TLS connection.
+     */
+    Require,
+    /**
+     * Disable TLS for a local proxy connection.
+     */
+    Disable,
+    /**
+     * Prefer TLS when the server supports it.
+     */
+    Prefer
+}
+
+const FfiConverterTypeSslMode = (() => {
+    type TypeName = SslMode;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return SslMode.Require;
+                case 2: return SslMode.Disable;
+                case 3: return SslMode.Prefer;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case SslMode.Require: return c.writeI32(1);
+                case SslMode.Disable: return c.writeI32(2);
+                case SslMode.Prefer: return c.writeI32(3);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * Connection and resource fields recovered from a Lakebase address.
+ */
+export type ParsedAddress = {
+    /**
+     * Lakebase Postgres project identifier.
+     */
+    project?: string,
+    /**
+     * Branch identifier within the project.
+     */
+    branch?: string,
+    /**
+     * Canonical endpoint resource path.
+     */
+    endpoint?: string,
+    /**
+     * Endpoint leaf identifier.
+     */
+    endpointId?: string,
+    /**
+     * PostgreSQL database name.
+     */
+    database?: string,
+    /**
+     * Database resource leaf identifier.
+     */
+    databaseResourceId?: string,
+    /**
+     * PostgreSQL user or Databricks profile from a URL.
+     */
+    user?: string,
+    /**
+     * Endpoint or local proxy host.
+     */
+    host?: string,
+    /**
+     * PostgreSQL port.
+     */
+    port?: number,
+    /**
+     * PostgreSQL TLS mode.
+     */
+    sslMode?: SslMode
+}
+
+/**
+ * Generated factory for {@link ParsedAddress} record objects.
+ */
+export const ParsedAddress = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ParsedAddress, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ParsedAddress>,
+    });
+})();
+
+const FfiConverterTypeParsedAddress = (() => {
+    type TypeName = ParsedAddress;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            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: TypeName, c: Cursor): void {
+            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: TypeName): number {
+            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();
+})();
+
+/**
+ * OAuth grant used to acquire and renew credentials.
+ */
+export enum OAuthGrant {
+    /**
+     * Browser authorization-code grant with PKCE and refresh-token renewal.
+     */
+    AuthorizationCode,
+    /**
+     * Noninteractive client-credentials grant renewed by repeating the exchange.
+     */
+    ClientCredentials
+}
+
+const FfiConverterTypeOAuthGrant = (() => {
+    type TypeName = OAuthGrant;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return OAuthGrant.AuthorizationCode;
+                case 2: return OAuthGrant.ClientCredentials;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case OAuthGrant.AuthorizationCode: return c.writeI32(1);
+                case OAuthGrant.ClientCredentials: return c.writeI32(2);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * File organization used by the persistent credential store.
+ */
+export enum FileLayout {
+    /**
+     * Store all credentials in one token cache.
+     */
+    Single,
+    /**
+     * Store each credential in an independent hashed directory.
+     */
+    PerCredential
+}
+
+const FfiConverterTypeFileLayout = (() => {
+    type TypeName = FileLayout;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return FileLayout.Single;
+                case 2: return FileLayout.PerCredential;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case FileLayout.Single: return c.writeI32(1);
+                case FileLayout.PerCredential: return c.writeI32(2);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * Provider-specific OAuth identity, endpoints, storage, and shared lifecycle options.
+ */
+export type ProviderOptions = {
+    /**
+     * Stable provider identity used to isolate stored credentials.
+     */
+    provider: string,
+    /**
+     * OAuth application identifier.
+     */
+    clientId: string,
+    /**
+     * Provider's token exchange endpoint.
+     */
+    tokenEndpoint: string,
+    /**
+     * Required browser authorization endpoint for authorization-code grants.
+     */
+    authorizationEndpoint?: string,
+    /**
+     * Secret for confidential clients; never returned in access-token results.
+     */
+    clientSecret?: string,
+    /**
+     * Optional namespace for multiple accounts under one provider.
+     */
+    profile?: string,
+    /**
+     * Requested scopes, trimmed, sorted, and deduplicated before use.
+     */
+    scopes: Array<string>,
+    /**
+     * Defaults to authorization code with PKCE when omitted.
+     */
+    grant?: OAuthGrant,
+    /**
+     * Override the provider-neutral credential directory.
+     */
+    cacheDir?: string,
+    /**
+     * Select a built-in store; omission uses file storage.
+     */
+    storage?: Storage,
+    /**
+     * Select a shared cache file or independent credential files.
+     */
+    fileLayout?: FileLayout,
+    /**
+     * Shared lifecycle configuration; omission uses `AuthOptions::default()`.
+     */
+    auth?: AuthOptions
+}
+
+/**
+ * Generated factory for {@link ProviderOptions} record objects.
+ */
+export const ProviderOptions = (() => {
+    const defaults = () => ({
+        authorizationEndpoint: undefined,
+        clientSecret: undefined,
+        profile: undefined,
+        scopes: [],
+        grant: undefined,
+        cacheDir: undefined,
+        storage: undefined,
+        fileLayout: undefined,
+        auth: undefined
+    });
+    const create = (() => {
+        return uniffiCreateRecord<ProviderOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<ProviderOptions>,
+    });
+})();
+
+const FfiConverterTypeProviderOptions = (() => {
+    type TypeName = ProviderOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            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: TypeName, c: Cursor): void {
+            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: TypeName): number {
+            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();
+})();
+
+
+// Error type: AuthError
+export enum AuthError_Tags {
+    Failure = "Failure"
+}
+/**
+ * Authentication failure exposed through language bindings.
+ */
+export const AuthError = (() => {
+
+    type Failure__interface = {
+        tag: AuthError_Tags.Failure;
+        inner:
+Readonly<{message: string}>
+    };
+    /**
+     * Native authentication, storage, configuration, or callback failure.
+     */
+    class Failure_ extends UniffiError implements Failure__interface {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        readonly [uniffiTypeNameSymbol] = "AuthError";
+        readonly tag = AuthError_Tags.Failure;
+        readonly inner:
+Readonly<{message: string}>;
+        constructor(
+inner: {message: string }) {
+            super("AuthError", "Failure");
+
+            this.inner = Object.freeze(inner);
+        }
+        static new(
+inner: {message: string }): Failure_ {
+            return new Failure_(inner);
+        }
+
+        static instanceOf(obj: any): obj is Failure_ {
+            return obj.tag === AuthError_Tags.Failure;
+        }
+        static hasInner(obj: any): obj is Failure_ {
+            return Failure_.instanceOf(obj);
+        }
+
+        static getInner(obj: Failure_):
+Readonly<{message: string}> {
+            return obj.inner;
+        }
+
+    }
+
+    function instanceOf(obj: any): obj is AuthError {
+        return obj[uniffiTypeNameSymbol] === "AuthError";
+    }
+
+    return Object.freeze({
+        instanceOf,
+  Failure: Failure_
+    });
+
+})();
+/**
+ * Authentication failure exposed through language bindings.
+ */
+export type AuthError = InstanceType<
+    typeof AuthError['Failure']
+>;
+
+// FfiConverter for enum AuthError
+const FfiConverterTypeAuthError = (() => {
+    type TypeName = AuthError;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return new AuthError.Failure({message: FfiConverterString.readFromCursor(c) });
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value.tag) {
+                case AuthError_Tags.Failure: {
+                    c.writeI32(1);
+                    const inner = value.inner;
+                    FfiConverterString.writeIntoCursor(inner.message, c);
+                    return;
+                }
+                default:
+                    // Throwing from here means that AuthError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value: TypeName): number {
+            switch (value.tag) {
+                case AuthError_Tags.Failure: {
+                    const inner = value.inner;
+                    let size = 4;
+                    size += FfiConverterString.allocationSize(inner.message);
+                    return size;
+                }
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * Databricks binding facade over the shared persistent authentication lifecycle.
+ */
+export interface PersistentAuthLike {
+
+/**
+ * Return a current authorization header when the request URL matches the profile origin.
+ */
+    authorizationHeaderForUrl(requestUrl: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<string | undefined>;
+/**
+ * Start an explicit login and persist the resulting credential.
+ */
+    challenge(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Renew the stored credential even before its refresh window.
+ */
+    forceRefreshToken(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<AccessToken>;
+/**
+ * Delete the credential while holding the store's refresh lock.
+ */
+    logout(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Reuse another caller's replacement or renew the rejected token.
+ */
+    refreshRejectedToken(staleAccessToken: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<AccessToken>;
+/**
+ * Return the resolved identity and active built-in storage backend.
+ */
+    status(): DatabricksAuthStatus;
+/**
+ * True forces login, false forbids interactive login, and omission permits missing-token login.
+ */
+    token(login?: boolean | undefined, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<AccessToken>;
+}
+/**
+ * @deprecated Use `PersistentAuthLike` instead.
+ */
+export type PersistentAuthInterface = PersistentAuthLike;
+
+
+/**
+ * Databricks binding facade over the shared persistent authentication lifecycle.
+ */
+export class PersistentAuth extends UniffiAbstractObject implements PersistentAuthLike {
+
+    readonly [uniffiTypeNameSymbol] = "PersistentAuth";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypePersistentAuthObjectFactory.bless(pointer);
+}
+
+
+
+
+/**
+ * Return a current authorization header when the request URL matches the profile origin.
+ */
+    async authorizationHeaderForUrl(requestUrl: string, asyncOpts_?: { signal: AbortSignal }): Promise<string | undefined> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_persistentauth_authorization_header_for_url(
+                    uniffiTypePersistentAuthObjectFactory.clonePointer(this),FfiConverterString.lower(requestUrl, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            // Borrowed view over foreign memory: the call site owns the free,
+            // as on the sync paths. Unconditional — a no-op where buffers are
+            // already JS-owned.
+            /*liftFunc:*/ (__rb) => {
+                try {
+                    return FfiConverterOptionalString.lift(__rb);
+                } finally {
+                    nativeModule().rustbuffer_free(__rb);
+                }
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Start an explicit login and persist the resulting credential.
+ */
+    async challenge(asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_persistentauth_challenge(
+                    uniffiTypePersistentAuthObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Renew the stored credential even before its refresh window.
+ */
+    async forceRefreshToken(asyncOpts_?: { signal: AbortSignal }): Promise<AccessToken> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_persistentauth_force_refresh_token(
+                    uniffiTypePersistentAuthObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            // Borrowed view over foreign memory: the call site owns the free,
+            // as on the sync paths. Unconditional — a no-op where buffers are
+            // already JS-owned.
+            /*liftFunc:*/ (__rb) => {
+                try {
+                    return FfiConverterTypeAccessToken.lift(__rb);
+                } finally {
+                    nativeModule().rustbuffer_free(__rb);
+                }
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Delete the credential while holding the store's refresh lock.
+ */
+    async logout(asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_persistentauth_logout(
+                    uniffiTypePersistentAuthObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Reuse another caller's replacement or renew the rejected token.
+ */
+    async refreshRejectedToken(staleAccessToken: string, asyncOpts_?: { signal: AbortSignal }): Promise<AccessToken> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_persistentauth_refresh_rejected_token(
+                    uniffiTypePersistentAuthObjectFactory.clonePointer(this),FfiConverterString.lower(staleAccessToken, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            // Borrowed view over foreign memory: the call site owns the free,
+            // as on the sync paths. Unconditional — a no-op where buffers are
+            // already JS-owned.
+            /*liftFunc:*/ (__rb) => {
+                try {
+                    return FfiConverterTypeAccessToken.lift(__rb);
+                } finally {
+                    nativeModule().rustbuffer_free(__rb);
+                }
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Return the resolved identity and active built-in storage backend.
+ */
+    status(): DatabricksAuthStatus {
+    const __rb: Uint8Array = uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_persistentauth_status(
+                uniffiTypePersistentAuthObjectFactory.clonePointer(this),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    try {
+        return FfiConverterTypeDatabricksAuthStatus.lift(__rb);
+    } finally {
+        nativeModule().rustbuffer_free(__rb);
+    }
+    }
+
+/**
+ * True forces login, false forbids interactive login, and omission permits missing-token login.
+ */
+    async token(login: boolean | undefined = undefined, asyncOpts_?: { signal: AbortSignal }): Promise<AccessToken> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_persistentauth_token(
+                    uniffiTypePersistentAuthObjectFactory.clonePointer(this),FfiConverterOptionalBoolean.lower(login, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            // Borrowed view over foreign memory: the call site owns the free,
+            // as on the sync paths. Unconditional — a no-op where buffers are
+            // already JS-owned.
+            /*liftFunc:*/ (__rb) => {
+                try {
+                    return FfiConverterTypeAccessToken.lift(__rb);
+                } finally {
+                    nativeModule().rustbuffer_free(__rb);
+                }
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypePersistentAuthObjectFactory.pointer(this);
+            uniffiTypePersistentAuthObjectFactory.freePointer(pointer);
+            uniffiTypePersistentAuthObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj_: any): obj_ is PersistentAuth {
+        return uniffiTypePersistentAuthObjectFactory.isConcreteType(obj_);
+    }
+
+
+}
+
+const uniffiTypePersistentAuthObjectFactory: UniffiObjectFactory<PersistentAuthLike> = (() => {
+
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry<UniffiHandle>((heldValue: UniffiHandle) => {
+        uniffiTypePersistentAuthObjectFactory.freePointer(heldValue);
+    }) : null;
+
+    return {
+    create(pointer: UniffiHandle): PersistentAuthLike {
+        const instance = Object.create(PersistentAuth.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "PersistentAuth";
+        return instance;
+    },
+
+
+    bless(p: UniffiHandle): UniffiGcObject {
+        const ptr = {
+            p, // make sure this object doesn't get optimized away.
+            markDestroyed: () => undefined,
+        };
+        if (registry) {
+            registry.register(ptr, p, ptr);
+        }
+        return ptr;
+    },
+
+    unbless(ptr_: UniffiGcObject) {
+        if (registry) {
+            registry.unregister(ptr_);
+        }
+    },
+
+    pointer(obj_: PersistentAuthLike): UniffiHandle {
+        if ((obj_ as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj_ as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj_: PersistentAuthLike): UniffiHandle {
+        const pointer = this.pointer(obj_);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_core_fn_clone_persistentauth(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_core_fn_free_persistentauth(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj_: any): obj_ is PersistentAuthLike {
+        return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "PersistentAuth";
+    },
+}})();
+const FfiConverterTypePersistentAuth = new FfiConverterObject(uniffiTypePersistentAuthObjectFactory);
+
+/**
+ * Generic OAuth provider using the shared persistent credential lifecycle.
+ */
+export interface ProviderAuthLike {
+
+/**
+ * Renew the credential even if it has not entered its refresh window.
+ */
+    forceRefreshToken(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<AccessToken>;
+/**
+ * Delete the stored credential while holding its refresh lock.
+ */
+    logout(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Reuse a concurrent replacement or renew the rejected access token.
+ */
+    refreshRejectedToken(staleAccessToken: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<AccessToken>;
+/**
+ * True forces login, false forbids interactive login, and omission permits missing-token login.
+ */
+    token(login?: boolean | undefined, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<AccessToken>;
+}
+/**
+ * @deprecated Use `ProviderAuthLike` instead.
+ */
+export type ProviderAuthInterface = ProviderAuthLike;
+
+
+/**
+ * Generic OAuth provider using the shared persistent credential lifecycle.
+ */
+export class ProviderAuth extends UniffiAbstractObject implements ProviderAuthLike {
+
+    readonly [uniffiTypeNameSymbol] = "ProviderAuth";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeProviderAuthObjectFactory.bless(pointer);
+}
+
+
+
+
+/**
+ * Renew the credential even if it has not entered its refresh window.
+ */
+    async forceRefreshToken(asyncOpts_?: { signal: AbortSignal }): Promise<AccessToken> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_providerauth_force_refresh_token(
+                    uniffiTypeProviderAuthObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            // Borrowed view over foreign memory: the call site owns the free,
+            // as on the sync paths. Unconditional — a no-op where buffers are
+            // already JS-owned.
+            /*liftFunc:*/ (__rb) => {
+                try {
+                    return FfiConverterTypeAccessToken.lift(__rb);
+                } finally {
+                    nativeModule().rustbuffer_free(__rb);
+                }
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Delete the stored credential while holding its refresh lock.
+ */
+    async logout(asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_providerauth_logout(
+                    uniffiTypeProviderAuthObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Reuse a concurrent replacement or renew the rejected access token.
+ */
+    async refreshRejectedToken(staleAccessToken: string, asyncOpts_?: { signal: AbortSignal }): Promise<AccessToken> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_providerauth_refresh_rejected_token(
+                    uniffiTypeProviderAuthObjectFactory.clonePointer(this),FfiConverterString.lower(staleAccessToken, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            // Borrowed view over foreign memory: the call site owns the free,
+            // as on the sync paths. Unconditional — a no-op where buffers are
+            // already JS-owned.
+            /*liftFunc:*/ (__rb) => {
+                try {
+                    return FfiConverterTypeAccessToken.lift(__rb);
+                } finally {
+                    nativeModule().rustbuffer_free(__rb);
+                }
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * True forces login, false forbids interactive login, and omission permits missing-token login.
+ */
+    async token(login: boolean | undefined = undefined, asyncOpts_?: { signal: AbortSignal }): Promise<AccessToken> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_providerauth_token(
+                    uniffiTypeProviderAuthObjectFactory.clonePointer(this),FfiConverterOptionalBoolean.lower(login, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            // Borrowed view over foreign memory: the call site owns the free,
+            // as on the sync paths. Unconditional — a no-op where buffers are
+            // already JS-owned.
+            /*liftFunc:*/ (__rb) => {
+                try {
+                    return FfiConverterTypeAccessToken.lift(__rb);
+                } finally {
+                    nativeModule().rustbuffer_free(__rb);
+                }
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeProviderAuthObjectFactory.pointer(this);
+            uniffiTypeProviderAuthObjectFactory.freePointer(pointer);
+            uniffiTypeProviderAuthObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj_: any): obj_ is ProviderAuth {
+        return uniffiTypeProviderAuthObjectFactory.isConcreteType(obj_);
+    }
+
+
+}
+
+const uniffiTypeProviderAuthObjectFactory: UniffiObjectFactory<ProviderAuthLike> = (() => {
+
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry<UniffiHandle>((heldValue: UniffiHandle) => {
+        uniffiTypeProviderAuthObjectFactory.freePointer(heldValue);
+    }) : null;
+
+    return {
+    create(pointer: UniffiHandle): ProviderAuthLike {
+        const instance = Object.create(ProviderAuth.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "ProviderAuth";
+        return instance;
+    },
+
+
+    bless(p: UniffiHandle): UniffiGcObject {
+        const ptr = {
+            p, // make sure this object doesn't get optimized away.
+            markDestroyed: () => undefined,
+        };
+        if (registry) {
+            registry.register(ptr, p, ptr);
+        }
+        return ptr;
+    },
+
+    unbless(ptr_: UniffiGcObject) {
+        if (registry) {
+            registry.unregister(ptr_);
+        }
+    },
+
+    pointer(obj_: ProviderAuthLike): UniffiHandle {
+        if ((obj_ as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj_ as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj_: ProviderAuthLike): UniffiHandle {
+        const pointer = this.pointer(obj_);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_core_fn_clone_providerauth(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_core_fn_free_providerauth(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj_: any): obj_ is ProviderAuthLike {
+        return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "ProviderAuth";
+    },
+}})();
+const FfiConverterTypeProviderAuth = new FfiConverterObject(uniffiTypeProviderAuthObjectFactory);
+
+/**
+ * Foreign-language persistence contract; implement every method in Node or Python.
+ *
+ * UniFFI callback interfaces do not inherit Rust default method bodies. A store
+ * must explicitly implement locking and may implement `prepare_write` as a no-op
+ * when writes need no preflight. Credential JSON can contain refresh tokens.
+ */
+export interface StorageAdapter {
+
+/**
+ * Load credential JSON, returning None when the key does not exist.
+ */
+    load(profile: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<string | undefined>;
+/**
+ * Check write readiness before a provider rotates a refresh token.
+ */
+    prepareWrite(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Persist credential JSON without discarding unrelated keys.
+ */
+    save(profile: string, token: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Delete only the specified credential.
+ */
+    remove(profile: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Acquire an exclusive refresh lease or fail within the timeout.
+ */
+    acquireLock(profile: string, timeoutMillis: bigint, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<string>;
+/**
+ * Release the lease returned by `acquire_lock`.
+ */
+    releaseLock(lease: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Return a human-readable backend identifier.
+ */
+    name(): string;
+}
+
+
+/**
+ * Foreign-language persistence contract; implement every method in Node or Python.
+ *
+ * UniFFI callback interfaces do not inherit Rust default method bodies. A store
+ * must explicitly implement locking and may implement `prepare_write` as a no-op
+ * when writes need no preflight. Credential JSON can contain refresh tokens.
+ */
+export class StorageAdapterImpl extends UniffiAbstractObject implements StorageAdapter {
+
+    readonly [uniffiTypeNameSymbol] = "StorageAdapterImpl";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeStorageAdapterImplObjectFactory.bless(pointer);
+}
+
+
+
+
+/**
+ * Load credential JSON, returning None when the key does not exist.
+ */
+    async load(profile: string, asyncOpts_?: { signal: AbortSignal }): Promise<string | undefined> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_storageadapter_load(
+                    uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this),FfiConverterString.lower(profile, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            // Borrowed view over foreign memory: the call site owns the free,
+            // as on the sync paths. Unconditional — a no-op where buffers are
+            // already JS-owned.
+            /*liftFunc:*/ (__rb) => {
+                try {
+                    return FfiConverterOptionalString.lift(__rb);
+                } finally {
+                    nativeModule().rustbuffer_free(__rb);
+                }
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Check write readiness before a provider rotates a refresh token.
+ */
+    async prepareWrite(asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_storageadapter_prepare_write(
+                    uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Persist credential JSON without discarding unrelated keys.
+ */
+    async save(profile: string, token: string, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_storageadapter_save(
+                    uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this),FfiConverterString.lower(profile, nativeModule().rustbuffer_alloc),FfiConverterString.lower(token, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Delete only the specified credential.
+ */
+    async remove(profile: string, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_storageadapter_remove(
+                    uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this),FfiConverterString.lower(profile, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Acquire an exclusive refresh lease or fail within the timeout.
+ */
+    async acquireLock(profile: string, timeoutMillis: bigint, asyncOpts_?: { signal: AbortSignal }): Promise<string> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_storageadapter_acquire_lock(
+                    uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this),FfiConverterString.lower(profile, nativeModule().rustbuffer_alloc),FfiConverterUInt64.lower(timeoutMillis, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_rust_buffer,
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            // Borrowed view over foreign memory: the call site owns the free,
+            // as on the sync paths. Unconditional — a no-op where buffers are
+            // already JS-owned.
+            /*liftFunc:*/ (__rb) => {
+                try {
+                    return FfiConverterString.lift(__rb);
+                } finally {
+                    nativeModule().rustbuffer_free(__rb);
+                }
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Release the lease returned by `acquire_lock`.
+ */
+    async releaseLock(lease: string, asyncOpts_?: { signal: AbortSignal }): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_storageadapter_release_lock(
+                    uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this),FfiConverterString.lower(lease, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_core_rust_future_free_void,
+            /*liftFunc:*/ (_v) => {},
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+            /*asyncOpts:*/ asyncOpts_,
+            /*errorHandler:*/ FfiConverterTypeAuthError.lift.bind(FfiConverterTypeAuthError)
+        );
+    } catch (__error: any) {
+        if (uniffiIsDebug && __error instanceof Error) {
+            __error.stack = __stack;
+        }
+        throw __error;
+    }
+    }
+
+/**
+ * Return a human-readable backend identifier.
+ */
+    name(): string {
+    const __rb: Uint8Array = uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_core_fn_method_storageadapter_name(
+                uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    try {
+        return FfiConverterString.lift(__rb);
+    } finally {
+        nativeModule().rustbuffer_free(__rb);
+    }
+    }
+
+
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeStorageAdapterImplObjectFactory.pointer(this);
+            uniffiTypeStorageAdapterImplObjectFactory.freePointer(pointer);
+            uniffiTypeStorageAdapterImplObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj_: any): obj_ is StorageAdapterImpl {
+        return uniffiTypeStorageAdapterImplObjectFactory.isConcreteType(obj_);
+    }
+
+
+}
+
+const uniffiTypeStorageAdapterImplObjectFactory: UniffiObjectFactory<StorageAdapter> = (() => {
+
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry<UniffiHandle>((heldValue: UniffiHandle) => {
+        uniffiTypeStorageAdapterImplObjectFactory.freePointer(heldValue);
+    }) : null;
+
+    return {
+    create(pointer: UniffiHandle): StorageAdapter {
+        const instance = Object.create(StorageAdapterImpl.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "StorageAdapterImpl";
+        return instance;
+    },
+
+
+    bless(p: UniffiHandle): UniffiGcObject {
+        const ptr = {
+            p, // make sure this object doesn't get optimized away.
+            markDestroyed: () => undefined,
+        };
+        if (registry) {
+            registry.register(ptr, p, ptr);
+        }
+        return ptr;
+    },
+
+    unbless(ptr_: UniffiGcObject) {
+        if (registry) {
+            registry.unregister(ptr_);
+        }
+    },
+
+    pointer(obj_: StorageAdapter): UniffiHandle {
+        if ((obj_ as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj_ as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj_: StorageAdapter): UniffiHandle {
+        const pointer = this.pointer(obj_);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_core_fn_clone_storageadapter(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_core_fn_free_storageadapter(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj_: any): obj_ is StorageAdapter {
+        return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "StorageAdapterImpl";
+    },
+}})();
+const FfiConverterTypeStorageAdapter = new FfiConverterObjectWithCallbacks(uniffiTypeStorageAdapterImplObjectFactory);
+
+// Add a vtable for the callbacks that go in StorageAdapter.
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceStorageAdapter: { vtable: any; register: () => void; } = {
+    // Create the VTable using a series of closures.
+    // ts automatically converts these into C callback functions.
+    vtable: {
+        load: (
+            uniffiHandle: bigint,
+            profile: Uint8Array,
+            uniffiFutureCallback: UniffiForeignFutureCompleterustBuffer,
+            uniffiCallbackData: bigint) => {
+            const uniffiMakeCall =
+            async (signal: AbortSignal)
+            : Promise<string | undefined> => {
+                const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+                return await jsCallback.load(
+                    FfiConverterString.lift(profile), { signal }
+                )
+            };
+            const uniffiHandleSuccess = (returnValue: string | undefined) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultRustBuffer */{
+                        return_value: FfiConverterOptionalString.lower(returnValue, nativeModule().rustbuffer_alloc),
+                        call_status: uniffiCaller.createCallStatus()
+                    }
+                );
+            };
+            const uniffiHandleError = (code: number, errorBuf: UniffiByteArray) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultRustBuffer */{
+                        return_value: /*empty*/ new Uint8Array(0),
+                        // TODO create callstatus with error.
+                        call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                    }
+                );
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                /*makeCall:*/ uniffiMakeCall,
+                /*handleSuccess:*/ uniffiHandleSuccess,
+                /*handleError:*/ uniffiHandleError,
+                /*isErrorType:*/ AuthError.instanceOf,
+                /*lowerError:*/ FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError),
+                /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString),
+                /*alloc:*/ nativeModule().rustbuffer_alloc,
+            );
+            return uniffiForeignFuture;
+        },
+        prepare_write: (
+            uniffiHandle: bigint,
+            uniffiFutureCallback: UniffiForeignFutureCompletevoid,
+            uniffiCallbackData: bigint) => {
+            const uniffiMakeCall =
+            async (signal: AbortSignal)
+            : Promise<void> => {
+                const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+                return await jsCallback.prepareWrite({ signal }
+                )
+            };
+            const uniffiHandleSuccess = (returnValue: void) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultVoid */{
+                        call_status: uniffiCaller.createCallStatus()
+                    }
+                );
+            };
+            const uniffiHandleError = (code: number, errorBuf: UniffiByteArray) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultVoid */{
+                        // TODO create callstatus with error.
+                        call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                    }
+                );
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                /*makeCall:*/ uniffiMakeCall,
+                /*handleSuccess:*/ uniffiHandleSuccess,
+                /*handleError:*/ uniffiHandleError,
+                /*isErrorType:*/ AuthError.instanceOf,
+                /*lowerError:*/ FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError),
+                /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString),
+                /*alloc:*/ nativeModule().rustbuffer_alloc,
+            );
+            return uniffiForeignFuture;
+        },
+        save: (
+            uniffiHandle: bigint,
+            profile: Uint8Array,
+            token: Uint8Array,
+            uniffiFutureCallback: UniffiForeignFutureCompletevoid,
+            uniffiCallbackData: bigint) => {
+            const uniffiMakeCall =
+            async (signal: AbortSignal)
+            : Promise<void> => {
+                const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+                return await jsCallback.save(
+                    FfiConverterString.lift(profile),
+                    FfiConverterString.lift(token), { signal }
+                )
+            };
+            const uniffiHandleSuccess = (returnValue: void) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultVoid */{
+                        call_status: uniffiCaller.createCallStatus()
+                    }
+                );
+            };
+            const uniffiHandleError = (code: number, errorBuf: UniffiByteArray) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultVoid */{
+                        // TODO create callstatus with error.
+                        call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                    }
+                );
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                /*makeCall:*/ uniffiMakeCall,
+                /*handleSuccess:*/ uniffiHandleSuccess,
+                /*handleError:*/ uniffiHandleError,
+                /*isErrorType:*/ AuthError.instanceOf,
+                /*lowerError:*/ FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError),
+                /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString),
+                /*alloc:*/ nativeModule().rustbuffer_alloc,
+            );
+            return uniffiForeignFuture;
+        },
+        remove: (
+            uniffiHandle: bigint,
+            profile: Uint8Array,
+            uniffiFutureCallback: UniffiForeignFutureCompletevoid,
+            uniffiCallbackData: bigint) => {
+            const uniffiMakeCall =
+            async (signal: AbortSignal)
+            : Promise<void> => {
+                const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+                return await jsCallback.remove(
+                    FfiConverterString.lift(profile), { signal }
+                )
+            };
+            const uniffiHandleSuccess = (returnValue: void) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultVoid */{
+                        call_status: uniffiCaller.createCallStatus()
+                    }
+                );
+            };
+            const uniffiHandleError = (code: number, errorBuf: UniffiByteArray) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultVoid */{
+                        // TODO create callstatus with error.
+                        call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                    }
+                );
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                /*makeCall:*/ uniffiMakeCall,
+                /*handleSuccess:*/ uniffiHandleSuccess,
+                /*handleError:*/ uniffiHandleError,
+                /*isErrorType:*/ AuthError.instanceOf,
+                /*lowerError:*/ FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError),
+                /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString),
+                /*alloc:*/ nativeModule().rustbuffer_alloc,
+            );
+            return uniffiForeignFuture;
+        },
+        acquire_lock: (
+            uniffiHandle: bigint,
+            profile: Uint8Array,
+            timeoutMillis: bigint,
+            uniffiFutureCallback: UniffiForeignFutureCompleterustBuffer,
+            uniffiCallbackData: bigint) => {
+            const uniffiMakeCall =
+            async (signal: AbortSignal)
+            : Promise<string> => {
+                const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+                return await jsCallback.acquireLock(
+                    FfiConverterString.lift(profile),
+                    FfiConverterUInt64.lift(timeoutMillis), { signal }
+                )
+            };
+            const uniffiHandleSuccess = (returnValue: string) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultRustBuffer */{
+                        return_value: FfiConverterString.lower(returnValue, nativeModule().rustbuffer_alloc),
+                        call_status: uniffiCaller.createCallStatus()
+                    }
+                );
+            };
+            const uniffiHandleError = (code: number, errorBuf: UniffiByteArray) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultRustBuffer */{
+                        return_value: /*empty*/ new Uint8Array(0),
+                        // TODO create callstatus with error.
+                        call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                    }
+                );
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                /*makeCall:*/ uniffiMakeCall,
+                /*handleSuccess:*/ uniffiHandleSuccess,
+                /*handleError:*/ uniffiHandleError,
+                /*isErrorType:*/ AuthError.instanceOf,
+                /*lowerError:*/ FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError),
+                /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString),
+                /*alloc:*/ nativeModule().rustbuffer_alloc,
+            );
+            return uniffiForeignFuture;
+        },
+        release_lock: (
+            uniffiHandle: bigint,
+            lease: Uint8Array,
+            uniffiFutureCallback: UniffiForeignFutureCompletevoid,
+            uniffiCallbackData: bigint) => {
+            const uniffiMakeCall =
+            async (signal: AbortSignal)
+            : Promise<void> => {
+                const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+                return await jsCallback.releaseLock(
+                    FfiConverterString.lift(lease), { signal }
+                )
+            };
+            const uniffiHandleSuccess = (returnValue: void) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultVoid */{
+                        call_status: uniffiCaller.createCallStatus()
+                    }
+                );
+            };
+            const uniffiHandleError = (code: number, errorBuf: UniffiByteArray) => {
+                uniffiFutureCallback.call(
+                    uniffiFutureCallback,
+                    uniffiCallbackData,
+                    /* UniffiForeignFutureResultVoid */{
+                        // TODO create callstatus with error.
+                        call_status: uniffiCaller.createErrorStatus(code, errorBuf),
+                    }
+                );
+            };
+            const uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                /*makeCall:*/ uniffiMakeCall,
+                /*handleSuccess:*/ uniffiHandleSuccess,
+                /*handleError:*/ uniffiHandleError,
+                /*isErrorType:*/ AuthError.instanceOf,
+                /*lowerError:*/ FfiConverterTypeAuthError.lower.bind(FfiConverterTypeAuthError),
+                /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString),
+                /*alloc:*/ nativeModule().rustbuffer_alloc,
+            );
+            return uniffiForeignFuture;
+        },
+        name: (
+            uniffiHandle: bigint,) => {
+            const uniffiMakeCall =
+            ()
+            : string => {
+                const jsCallback = FfiConverterTypeStorageAdapter.lift(uniffiHandle);
+                return jsCallback.name(
+                )
+            };
+            const uniffiResult = UniffiResult.ready<Uint8Array>();
+            const uniffiHandleSuccess = (obj: any) => {
+                UniffiResult.writeSuccess(uniffiResult, FfiConverterString.lower(obj, nativeModule().rustbuffer_alloc));
+            };
+            const uniffiHandleError = (code: number, errBuf: UniffiByteArray) => {
+                UniffiResult.writeError(uniffiResult, code, errBuf);
+            };
+            uniffiTraitInterfaceCall(
+                /*makeCall:*/ uniffiMakeCall,
+                /*handleSuccess:*/ uniffiHandleSuccess,
+                /*handleError:*/ uniffiHandleError,
+                /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString),
+                /*alloc:*/ nativeModule().rustbuffer_alloc,
+            )
+            return uniffiResult;
+        },
+        uniffi_free: (uniffiHandle: UniffiHandle): void => {
+            // this will throw a stale handle error if the handle isn't found.
+            FfiConverterTypeStorageAdapter.drop(uniffiHandle);
+        },
+        uniffi_clone: (uniffiHandle: UniffiHandle): UniffiHandle => {
+            return FfiConverterTypeStorageAdapter.clone(uniffiHandle);
+        }
+    },
+    register: () => {nativeModule().uniffi_dbx_tools_core_fn_init_callback_vtable_storageadapter(
+            uniffiCallbackInterfaceStorageAdapter.vtable
+        );
+    },
+};
+
+/**
+ * Keeps storage callbacks in the native library that owns their converters.
+ */
+export interface StorageHandleLike {
+
+}
+/**
+ * @deprecated Use `StorageHandleLike` instead.
+ */
+export type StorageHandleInterface = StorageHandleLike;
+
+
+/**
+ * Keeps storage callbacks in the native library that owns their converters.
+ */
+export class StorageHandle extends UniffiAbstractObject implements StorageHandleLike {
+
+    readonly [uniffiTypeNameSymbol] = "StorageHandle";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeStorageHandleObjectFactory.bless(pointer);
+}
+
+
+
+
+
+    uniffiDestroy(): void {
+        const ptr = (this as any)[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeStorageHandleObjectFactory.pointer(this);
+            uniffiTypeStorageHandleObjectFactory.freePointer(pointer);
+            uniffiTypeStorageHandleObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj_: any): obj_ is StorageHandle {
+        return uniffiTypeStorageHandleObjectFactory.isConcreteType(obj_);
+    }
+
+
+}
+
+const uniffiTypeStorageHandleObjectFactory: UniffiObjectFactory<StorageHandleLike> = (() => {
+
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry<UniffiHandle>((heldValue: UniffiHandle) => {
+        uniffiTypeStorageHandleObjectFactory.freePointer(heldValue);
+    }) : null;
+
+    return {
+    create(pointer: UniffiHandle): StorageHandleLike {
+        const instance = Object.create(StorageHandle.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "StorageHandle";
+        return instance;
+    },
+
+
+    bless(p: UniffiHandle): UniffiGcObject {
+        const ptr = {
+            p, // make sure this object doesn't get optimized away.
+            markDestroyed: () => undefined,
+        };
+        if (registry) {
+            registry.register(ptr, p, ptr);
+        }
+        return ptr;
+    },
+
+    unbless(ptr_: UniffiGcObject) {
+        if (registry) {
+            registry.unregister(ptr_);
+        }
+    },
+
+    pointer(obj_: StorageHandleLike): UniffiHandle {
+        if ((obj_ as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj_ as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj_: StorageHandleLike): UniffiHandle {
+        const pointer = this.pointer(obj_);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_core_fn_clone_storagehandle(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_core_fn_free_storagehandle(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj_: any): obj_ is StorageHandleLike {
+        return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "StorageHandle";
+    },
+}})();
+const FfiConverterTypeStorageHandle = new FfiConverterObject(uniffiTypeStorageHandleObjectFactory);
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+// FfiConverter for Array<string>
+const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
+
+// FfiConverter for Array<string> | undefined
+const FfiConverterOptionalSequenceString = new FfiConverterOptional(FfiConverterSequenceString);
+
+// FfiConverter for AuthOptions | undefined
+const FfiConverterOptionalTypeAuthOptions = new FfiConverterOptional(FfiConverterTypeAuthOptions);
+
+// FfiConverter for Map<string, string>
+const FfiConverterMapStringString = new FfiConverterMap(FfiConverterString, FfiConverterString);
+
+// FfiConverter for Map<string, string> | undefined
+const FfiConverterOptionalMapStringString = new FfiConverterOptional(FfiConverterMapStringString);
+
+// FfiConverter for number | undefined
+const FfiConverterOptionalUInt16 = new FfiConverterOptional(FfiConverterUInt16);
+
+// FfiConverter for SslMode | undefined
+const FfiConverterOptionalTypeSslMode = new FfiConverterOptional(FfiConverterTypeSslMode);
+
+// FfiConverter for OAuthGrant | undefined
+const FfiConverterOptionalTypeOAuthGrant = new FfiConverterOptional(FfiConverterTypeOAuthGrant);
+
+// FfiConverter for Storage | undefined
+const FfiConverterOptionalTypeStorage = new FfiConverterOptional(FfiConverterTypeStorage);
+
+// FfiConverter for FileLayout | undefined
+const FfiConverterOptionalTypeFileLayout = new FfiConverterOptional(FfiConverterTypeFileLayout);
+
+// FfiConverter for boolean | undefined
+const FfiConverterOptionalBoolean = new FfiConverterOptional(FfiConverterBool);
+
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+    // Get the bindings contract version from our ComponentInterface
+    const bindingsContractVersion = 30;
+    // Get the scaffolding contract version by calling the into the dylib
+    const scaffoldingContractVersion = nativeModule().ffi_dbx_tools_core_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_func_canonical_scopes() !== 62077) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_canonical_scopes");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_func_create_persistent_auth() !== 18830) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_create_persistent_auth");
+    }
+    if (nativeModule().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 (nativeModule().uniffi_dbx_tools_core_checksum_func_create_provider_auth() !== 4445) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_create_provider_auth");
+    }
+    if (nativeModule().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 (nativeModule().uniffi_dbx_tools_core_checksum_func_create_storage_handle() !== 15610) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_create_storage_handle");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_func_credential_key() !== 36458) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_credential_key");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_func_databricks_cli_available() !== 27788) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_databricks_cli_available");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_func_is_databricks_app() !== 52373) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_is_databricks_app");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_func_parse_address() !== 9538) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_parse_address");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_func_parse_resource_path() !== 62884) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_func_parse_resource_path");
+    }
+    if (nativeModule().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 (nativeModule().uniffi_dbx_tools_core_checksum_method_persistentauth_challenge() !== 32194) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_persistentauth_challenge");
+    }
+    if (nativeModule().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 (nativeModule().uniffi_dbx_tools_core_checksum_method_persistentauth_logout() !== 22550) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_persistentauth_logout");
+    }
+    if (nativeModule().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 (nativeModule().uniffi_dbx_tools_core_checksum_method_persistentauth_status() !== 3099) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_persistentauth_status");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_method_persistentauth_token() !== 38242) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_persistentauth_token");
+    }
+    if (nativeModule().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 (nativeModule().uniffi_dbx_tools_core_checksum_method_providerauth_logout() !== 64726) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_providerauth_logout");
+    }
+    if (nativeModule().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 (nativeModule().uniffi_dbx_tools_core_checksum_method_providerauth_token() !== 37517) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_providerauth_token");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_method_storageadapter_load() !== 54668) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_load");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_method_storageadapter_prepare_write() !== 45067) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_prepare_write");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_method_storageadapter_save() !== 63958) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_save");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_method_storageadapter_remove() !== 16750) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_remove");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_method_storageadapter_acquire_lock() !== 64986) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_acquire_lock");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_method_storageadapter_release_lock() !== 64198) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_release_lock");
+    }
+    if (nativeModule().uniffi_dbx_tools_core_checksum_method_storageadapter_name() !== 6080) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_core_checksum_method_storageadapter_name");
+    }
+
+    uniffiCallbackInterfaceStorageAdapter.register();
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeAccessToken,
+    FfiConverterTypeAuthError,
+    FfiConverterTypeAuthOptions,
+    FfiConverterTypeDatabricksAuthOptions,
+    FfiConverterTypeDatabricksAuthStatus,
+    FfiConverterTypeFileLayout,
+    FfiConverterTypeOAuthGrant,
+    FfiConverterTypeParsedAddress,
+    FfiConverterTypePersistentAuth,
+    FfiConverterTypeProviderAuth,
+    FfiConverterTypeProviderOptions,
+    FfiConverterTypeSslMode,
+    FfiConverterTypeStorage,
+    FfiConverterTypeStorageAdapter,
+    FfiConverterTypeStorageHandle,
+  }
+});