@dbx-tools/google-rs 0.6.188

package/src/_bindings.ts

@@ -0,0 +1,554 @@
+// GENERATED by UniFFI binding generation - DO NOT EDIT.
+// Regenerated from the dbx-tools-google 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,
+} from "./_bindings-ffi.ts";
+import { type AccessToken, type AuthOptions, AuthError,
+} from "@dbx-tools/core-rs";
+import { type FfiConverter, type UniffiByteArray, type UniffiGcObject, type UniffiHandle, type UniffiObjectFactory, AbstractFfiConverterByteArray, Cursor, FfiConverterObject, FfiConverterOptional, FfiConverterUInt64, RustBuffer, UniffiAbstractObject, UniffiInternalError, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiRustCallAsync, uniffiTypeNameSymbol,
+} from "@ubjs/core";
+import { uniffiModule as uniffiDbxToolsCoreModule } from "@dbx-tools/core-rs";
+const { FfiConverterTypeAccessToken, FfiConverterTypeAuthError, FfiConverterTypeAuthOptions } = uniffiDbxToolsCoreModule.converters;
+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.
+
+/**
+ * Load Google ADC from its standard source without invoking gcloud.
+ */
+export async function createGoogleAuth(options: GoogleAuthOptions, asyncOpts_?: { signal: AbortSignal }): Promise<GoogleAuthLike> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+        return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller,
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_dbx_tools_google_fn_func_create_google_auth(FfiConverterTypeGoogleAuthOptions.lower(options, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_poll_u64,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_cancel_u64,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_complete_u64,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_google_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:*/ FfiConverterTypeGoogleAuth.lift.bind(FfiConverterTypeGoogleAuth),
+            /*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;
+    }
+    }
+
+/**
+ * Options for Google Application Default Credentials.
+ */
+export type GoogleAuthOptions = {
+    /**
+     * Shared token lifetime and lock configuration.
+     */
+    auth?: AuthOptions,
+    /**
+     * Conservative lifetime used when the ADC provider omits token expiry.
+     */
+    accessTokenTtlSeconds: bigint
+}
+
+/**
+ * Generated factory for {@link GoogleAuthOptions} record objects.
+ */
+export const GoogleAuthOptions = (() => {
+    const defaults = () => ({
+        auth: undefined,
+        accessTokenTtlSeconds: BigInt("3600")
+    });
+    const create = (() => {
+        return uniffiCreateRecord<GoogleAuthOptions, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<GoogleAuthOptions>,
+    });
+})();
+
+const FfiConverterTypeGoogleAuthOptions = (() => {
+    type TypeName = GoogleAuthOptions;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                auth: FfiConverterOptionalTypeAuthOptions.readFromCursor(c),
+                accessTokenTtlSeconds: FfiConverterUInt64.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterOptionalTypeAuthOptions.writeIntoCursor(value.auth, c);
+            FfiConverterUInt64.writeIntoCursor(value.accessTokenTtlSeconds, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalTypeAuthOptions.allocationSize(value.auth) +
+             FfiConverterUInt64.allocationSize(value.accessTokenTtlSeconds);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+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);
+
+/**
+ * Active Google ADC source and access-token cache information.
+ */
+export type GoogleAuthStatus = {
+    /**
+     * ADC file selected through `GOOGLE_APPLICATION_CREDENTIALS` or gcloud's well-known path.
+     */
+    credentialsPath?: string,
+    /**
+     * Short-lived access tokens are retained only in process memory.
+     */
+    storage: string
+}
+
+/**
+ * Generated factory for {@link GoogleAuthStatus} record objects.
+ */
+export const GoogleAuthStatus = (() => {
+    const defaults = () => ({
+    });
+    const create = (() => {
+        return uniffiCreateRecord<GoogleAuthStatus, ReturnType<typeof defaults>>(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()) as Partial<GoogleAuthStatus>,
+    });
+})();
+
+const FfiConverterTypeGoogleAuthStatus = (() => {
+    type TypeName = GoogleAuthStatus;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            return {
+                credentialsPath: FfiConverterOptionalString.readFromCursor(c),
+                storage: FfiConverterString.readFromCursor(c)
+            };
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            FfiConverterOptionalString.writeIntoCursor(value.credentialsPath, c);
+            FfiConverterString.writeIntoCursor(value.storage, c);
+        }
+        allocationSize(value: TypeName): number {
+            return FfiConverterOptionalString.allocationSize(value.credentialsPath) +
+             FfiConverterString.allocationSize(value.storage);
+
+        }
+    };
+    return new FFIConverter();
+})();
+
+/**
+ * Google ADC binding facade over the shared in-process token lifecycle.
+ */
+export interface GoogleAuthLike {
+
+/**
+ * Refresh ADC even when the current token is outside its refresh window.
+ */
+    forceRefreshToken(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<AccessToken>;
+/**
+ * Clear the in-process access-token cache without modifying ADC.
+ */
+    logout(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<void>;
+/**
+ * Reuse a concurrent replacement or refresh the rejected access token.
+ */
+    refreshRejectedToken(staleAccessToken: string, asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<AccessToken>;
+/**
+ * Return the selected ADC path and short-lived token storage mode.
+ */
+    status(): GoogleAuthStatus;
+/**
+ * Return a cached token or refresh it from ADC.
+ */
+    token(asyncOpts_?: { signal: AbortSignal }) /*throws*/: Promise<AccessToken>;
+}
+/**
+ * @deprecated Use `GoogleAuthLike` instead.
+ */
+export type GoogleAuthInterface = GoogleAuthLike;
+
+
+/**
+ * Google ADC binding facade over the shared in-process token lifecycle.
+ */
+export class GoogleAuth extends UniffiAbstractObject implements GoogleAuthLike {
+
+    readonly [uniffiTypeNameSymbol] = "GoogleAuth";
+    readonly [destructorGuardSymbol]: UniffiGcObject;
+    readonly [pointerLiteralSymbol]: UniffiHandle;
+    // No primary constructor declared for this class.
+private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeGoogleAuthObjectFactory.bless(pointer);
+}
+
+
+
+
+/**
+ * Refresh ADC even when the current token is outside 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_google_fn_method_googleauth_force_refresh_token(
+                    uniffiTypeGoogleAuthObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_google_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;
+    }
+    }
+
+/**
+ * Clear the in-process access-token cache without modifying ADC.
+ */
+    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_google_fn_method_googleauth_logout(
+                    uniffiTypeGoogleAuthObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_poll_void,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_cancel_void,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_complete_void,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_google_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 refresh 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_google_fn_method_googleauth_refresh_rejected_token(
+                    uniffiTypeGoogleAuthObjectFactory.clonePointer(this),FfiConverterString.lower(staleAccessToken, nativeModule().rustbuffer_alloc)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_google_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 selected ADC path and short-lived token storage mode.
+ */
+    status(): GoogleAuthStatus {
+    const __rb: Uint8Array = uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_google_fn_method_googleauth_status(
+                uniffiTypeGoogleAuthObjectFactory.clonePointer(this),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    try {
+        return FfiConverterTypeGoogleAuthStatus.lift(__rb);
+    } finally {
+        nativeModule().rustbuffer_free(__rb);
+    }
+    }
+
+/**
+ * Return a cached token or refresh it from ADC.
+ */
+    async token(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_google_fn_method_googleauth_token(
+                    uniffiTypeGoogleAuthObjectFactory.clonePointer(this)
+                );
+            },
+            /*pollFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_poll_rust_buffer,
+            /*cancelFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_cancel_rust_buffer,
+            /*completeFunc:*/ nativeModule().ffi_dbx_tools_google_rust_future_complete_rust_buffer,
+            /*freeFunc:*/ nativeModule().ffi_dbx_tools_google_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 = uniffiTypeGoogleAuthObjectFactory.pointer(this);
+            uniffiTypeGoogleAuthObjectFactory.freePointer(pointer);
+            uniffiTypeGoogleAuthObjectFactory.unbless(ptr);
+            delete (this as any)[destructorGuardSymbol];
+        }
+    }
+
+    static instanceOf(obj_: any): obj_ is GoogleAuth {
+        return uniffiTypeGoogleAuthObjectFactory.isConcreteType(obj_);
+    }
+
+
+}
+
+const uniffiTypeGoogleAuthObjectFactory: UniffiObjectFactory<GoogleAuthLike> = (() => {
+
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistry<UniffiHandle>((heldValue: UniffiHandle) => {
+        uniffiTypeGoogleAuthObjectFactory.freePointer(heldValue);
+    }) : null;
+
+    return {
+    create(pointer: UniffiHandle): GoogleAuthLike {
+        const instance = Object.create(GoogleAuth.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "GoogleAuth";
+        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_: GoogleAuthLike): UniffiHandle {
+        if ((obj_ as any)[destructorGuardSymbol] === undefined) {
+            throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj_ as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj_: GoogleAuthLike): UniffiHandle {
+        const pointer = this.pointer(obj_);
+        return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_google_fn_clone_googleauth(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().uniffi_dbx_tools_google_fn_free_googleauth(pointer, callStatus),
+            /*liftString:*/ FfiConverterString.lift
+        );
+    },
+
+    isConcreteType(obj_: any): obj_ is GoogleAuthLike {
+        return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "GoogleAuth";
+    },
+}})();
+const FfiConverterTypeGoogleAuth = new FfiConverterObject(uniffiTypeGoogleAuthObjectFactory);
+
+// FfiConverter for AuthOptions | undefined
+const FfiConverterOptionalTypeAuthOptions = new FfiConverterOptional(FfiConverterTypeAuthOptions);
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+
+/**
+ * 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_google_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().uniffi_dbx_tools_google_checksum_func_create_google_auth() !== 8482) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_google_checksum_func_create_google_auth");
+    }
+    if (nativeModule().uniffi_dbx_tools_google_checksum_method_googleauth_force_refresh_token() !== 40538) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_google_checksum_method_googleauth_force_refresh_token");
+    }
+    if (nativeModule().uniffi_dbx_tools_google_checksum_method_googleauth_logout() !== 28220) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_google_checksum_method_googleauth_logout");
+    }
+    if (nativeModule().uniffi_dbx_tools_google_checksum_method_googleauth_refresh_rejected_token() !== 56472) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_google_checksum_method_googleauth_refresh_rejected_token");
+    }
+    if (nativeModule().uniffi_dbx_tools_google_checksum_method_googleauth_status() !== 21388) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_google_checksum_method_googleauth_status");
+    }
+    if (nativeModule().uniffi_dbx_tools_google_checksum_method_googleauth_token() !== 20454) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_google_checksum_method_googleauth_token");
+    }
+
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeGoogleAuth,
+    FfiConverterTypeGoogleAuthOptions,
+    FfiConverterTypeGoogleAuthStatus,
+  }
+});

package/src/bindings.ts

@@ -0,0 +1,12 @@
+// GENERATED by UniFFI binding generation - DO NOT EDIT.
+// Regenerated from the dbx-tools-google Rust exports.
+// Hand edits are overwritten on the next watch; this file is read-only.
+
+/* eslint-disable */
+// @ts-nocheck
+export * from './_bindings.ts';
+import uniffiModule from './_bindings.ts';
+uniffiModule.initialize();
+export { uniffiModule };
+export async function uniffiInitAsync() {}
+export type { GoogleAuthLike } from './_bindings.ts';