@dbx-tools/auth 0.6.161 → 0.6.167

package/src/_bindings.ts

@@ -0,0 +1,1794 @@
+// GENERATED by UniFFI binding generation - DO NOT EDIT.
+// Regenerated from the dbx-tools-auth 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 UniffiVTableCallbackInterfaceDbxToolsAuthStorageAdapter,
+} from "./_bindings-ffi.ts";
+import { type FfiConverter, type UniffiByteArray, type UniffiGcObject, type UniffiHandle, type UniffiObjectFactory, type UniffiReferenceHolder, type UniffiRustCallStatus, AbstractFfiConverterByteArray, Cursor, FfiConverterArray, FfiConverterBool, FfiConverterInt64, FfiConverterObject, FfiConverterObjectWithCallbacks, FfiConverterOptional, 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_auth_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);
+    }
+    }
+
+/**
+ * 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_auth_fn_func_create_provider_auth(FfiConverterTypeProviderOptions.lower(options, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_poll_u64,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_u64,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_u64,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_fn_func_create_provider_auth_with_storage(FfiConverterTypeProviderOptions.lower(options, nativeModule().rustbuffer_alloc),FfiConverterTypeStorageHandle.lower(storage, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_poll_u64,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_u64,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_u64,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_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_auth_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);
+    }
+    }
+
+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 = {
+    accessToken: string,
+    tokenType: string,
+    expiry?: string,
+    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();
+})();
+
+/**
+ * OAuth grant used to acquire and renew credentials.
+ */
+export enum OAuthGrant {
+    AuthorizationCode,
+    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();
+})();
+
+export enum Storage {
+    Auto,
+    Memory,
+    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();
+})();
+
+export enum FileLayout {
+    Single,
+    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"
+}
+export const AuthError = (() => {
+
+    type Failure__interface = {
+        tag: AuthError_Tags.Failure;
+        inner:
+Readonly<{message: string}>
+    };
+    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_
+    });
+
+})();
+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();
+})();
+
+/**
+ * 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_auth_fn_method_providerauth_force_refresh_token(
+                    uniffiTypeProviderAuthObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_fn_method_providerauth_logout(
+                    uniffiTypeProviderAuthObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_fn_method_providerauth_refresh_rejected_token(
+                    uniffiTypeProviderAuthObjectFactory.clonePointer(this),FfiConverterString.lower(staleAccessToken, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_fn_method_providerauth_token(
+                    uniffiTypeProviderAuthObjectFactory.clonePointer(this),FfiConverterOptionalBoolean.lower(login, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_fn_clone_providerauth(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_auth_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_auth_fn_method_storageadapter_load(
+                    uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this),FfiConverterString.lower(profile, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_fn_method_storageadapter_prepare_write(
+                    uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_fn_method_storageadapter_save(
+                    uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this),FfiConverterString.lower(profile, nativeModule().rustbuffer_alloc),FfiConverterString.lower(token, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_fn_method_storageadapter_remove(
+                    uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this),FfiConverterString.lower(profile, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_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_auth_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_fn_method_storageadapter_release_lock(
+                    uniffiTypeStorageAdapterImplObjectFactory.clonePointer(this),FfiConverterString.lower(lease, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_auth_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_auth_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_auth_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_auth_fn_clone_storageadapter(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_auth_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_auth_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_auth_fn_clone_storagehandle(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_auth_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 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 AuthOptions | undefined
+const FfiConverterOptionalTypeAuthOptions = new FfiConverterOptional(FfiConverterTypeAuthOptions);
+
+// 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_auth_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_func_canonical_scopes() !== 18689) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_func_canonical_scopes");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_func_create_provider_auth() !== 20751) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_func_create_provider_auth");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_func_create_provider_auth_with_storage() !== 25852) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_func_create_provider_auth_with_storage");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_func_create_storage_handle() !== 15844) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_func_create_storage_handle");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_func_credential_key() !== 22562) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_func_credential_key");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_method_providerauth_force_refresh_token() !== 35205) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_method_providerauth_force_refresh_token");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_method_providerauth_logout() !== 58116) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_method_providerauth_logout");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_method_providerauth_refresh_rejected_token() !== 40032) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_method_providerauth_refresh_rejected_token");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_method_providerauth_token() !== 54952) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_method_providerauth_token");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_method_storageadapter_load() !== 2549) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_method_storageadapter_load");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_method_storageadapter_prepare_write() !== 1371) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_method_storageadapter_prepare_write");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_method_storageadapter_save() !== 50464) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_method_storageadapter_save");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_method_storageadapter_remove() !== 46592) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_method_storageadapter_remove");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_method_storageadapter_acquire_lock() !== 13715) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_method_storageadapter_acquire_lock");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_method_storageadapter_release_lock() !== 42072) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_method_storageadapter_release_lock");
+    }
+    if (nativeModule().uniffi_dbx_tools_auth_checksum_method_storageadapter_name() !== 674) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_auth_checksum_method_storageadapter_name");
+    }
+
+    uniffiCallbackInterfaceStorageAdapter.register();
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeAccessToken,
+    FfiConverterTypeAuthError,
+    FfiConverterTypeAuthOptions,
+    FfiConverterTypeFileLayout,
+    FfiConverterTypeOAuthGrant,
+    FfiConverterTypeProviderAuth,
+    FfiConverterTypeProviderOptions,
+    FfiConverterTypeStorage,
+    FfiConverterTypeStorageAdapter,
+    FfiConverterTypeStorageHandle,
+  }
+});