@succinctlabs/react-native-zcam1 0.2.5

package/src/capture.tsx

@@ -0,0 +1,165 @@
+import { generateHardwareKey, getAttestation } from "@pagopa/io-react-native-integrity";
+import EncryptedStorage from "react-native-encrypted-storage";
+
+import { type ECKey, getContentPublicKey, getSecureEnclaveKeyId } from "./common";
+export { buildSelfSignedCertificate, SelfSignedCertChain } from "./bindings";
+
+/**
+ * Camera component for capturing photos with secure enclave integration.
+ */
+export {
+  type CameraFilmStyle,
+  type FilmStyleEffect,
+  type FilmStyleRecipe,
+  type HighlightShadowConfig,
+  type MonochromeConfig,
+  type WhiteBalanceConfig,
+  ZCamera,
+} from "./camera";
+
+import NativeZcam1Capture from "./NativeZcam1Capture";
+
+/**
+ * Present a native full-screen preview for any file using iOS QLPreviewController.
+ * Supports images, videos, PDFs, and other common file types with native playback controls.
+ * @param filePath Absolute filesystem path to the file.
+ */
+export async function previewFile(filePath: string): Promise<void> {
+  return NativeZcam1Capture.previewFile(filePath);
+}
+
+/**
+ * Flash mode for photo capture.
+ */
+export {
+  type AspectRatio,
+  type DeviceOrientation,
+  type FlashMode,
+  type Orientation,
+} from "./NativeZcam1Capture";
+
+/**
+ * Native video recording results.
+ */
+export type {
+  StartNativeVideoRecordingResult,
+  StopNativeVideoRecordingResult,
+} from "./NativeZcam1Capture";
+
+/**
+ * Device registration information including keys, certificate chain, and attestation.
+ */
+export type CaptureInfo = {
+  appId: string;
+  deviceKeyId: string;
+  contentPublicKey: ECKey;
+  contentKeyId: Uint8Array;
+  attestation: string;
+};
+
+/**
+ * Configuration settings for device initialization and backend communication.
+ */
+export type Settings = {
+  appId: string;
+  production: boolean;
+};
+
+/**
+ * Represents a captured photo with its original and processed file paths.
+ */
+export class ZPhoto {
+  originalPath: string;
+  path: string;
+
+  constructor(originalPath: string, path: string) {
+    this.originalPath = originalPath;
+    this.path = path;
+  }
+}
+
+/**
+ * Initializes the device by generating keys, obtaining certificate chain, and registering with the backend.
+ * @param settings - Configuration settings for initialization
+ * @returns Device information including keys, certificate chain, and attestation
+ */
+export async function initCapture(settings: Settings): Promise<CaptureInfo> {
+  let deviceKeyId = await EncryptedStorage.getItem(`deviceKeyId-${settings.appId}`);
+
+  const contentPublicKey = await getContentPublicKey();
+
+  if (contentPublicKey.kty !== "EC") {
+    throw "Only EC public keys are supported";
+  }
+
+  const contentKeyId = getSecureEnclaveKeyId(contentPublicKey);
+
+  if (deviceKeyId == null) {
+    // Try to generate hardware key, but fall back to mock for simulator
+    try {
+      deviceKeyId = await generateHardwareKey();
+    } catch (error: unknown) {
+      // If running in simulator, hardware key generation is not supported
+      const err = error as { code?: string; message?: string } | undefined;
+      if (err?.code === "-1" || err?.message?.includes("UNSUPPORTED_SERVICE")) {
+        console.warn(
+          "[ZCAM] Running in simulator - using mock device key. This is for development only.",
+        );
+        // Generate a mock device key for simulator testing
+        deviceKeyId = `SIMULATOR_DEVICE_KEY_${Date.now()}`;
+      } else {
+        throw error;
+      }
+    }
+    await EncryptedStorage.setItem(`deviceKeyId-${settings.appId}`, deviceKeyId);
+  }
+
+  if (deviceKeyId == null) {
+    throw "failed to generate a device key";
+  }
+
+  let attestation = await EncryptedStorage.getItem(`attestation-${deviceKeyId}`);
+
+  if (attestation == null) {
+    attestation = await updateRegistration(deviceKeyId, settings);
+  }
+
+  return {
+    appId: settings.appId,
+    deviceKeyId,
+    contentPublicKey,
+    contentKeyId,
+    attestation,
+  };
+}
+
+/**
+ * Updates device registration by performing attestation with the backend.
+ * @param keyId - The hardware key identifier
+ * @param settings - Configuration settings for registration
+ * @returns Attestation data and challenge
+ */
+export async function updateRegistration(keyId: string, _settings: Settings): Promise<string> {
+  // Try to get real attestation, but fall back to mock for simulator
+  let attestation: string;
+  try {
+    attestation = await getAttestation(keyId, keyId);
+  } catch (error: unknown) {
+    // If running in simulator, App Attest is not supported
+    const err = error as { code?: string; message?: string } | undefined;
+    if (err?.code === "-1" || err?.message?.includes("UNSUPPORTED_SERVICE")) {
+      console.warn(
+        "[ZCAM] Running in simulator - using mock attestation. This is for development only.",
+      );
+      // Use a mock attestation for simulator testing
+      // In production, this would need to be rejected by the backend
+      return `SIMULATOR_MOCK_${keyId}_${Date.now()}`;
+    } else {
+      throw error;
+    }
+  }
+
+  await EncryptedStorage.setItem(`attestation-${keyId}`, attestation);
+
+  return attestation;
+}

package/src/common.tsx

@@ -0,0 +1,46 @@
+import { sha1 } from "@noble/hashes/legacy.js";
+import { generate, getPublicKeyFixed, type PublicKey } from "@pagopa/io-react-native-crypto";
+import { base64, base64nopad, base64url, base64urlnopad } from "@scure/base";
+
+const CONTENT_KEY_TAG = "ZCAM1_CONTENT_KEY_TAG";
+
+export interface ECKey {
+  kty: "EC";
+  crv: string;
+  x: string;
+  y: string;
+}
+
+// Flexible base64 decoder that handles both standard and url-safe formats, with or without padding.
+// iOS Secure Enclave returns keys in varying formats depending on the iOS version.
+function flexibleBase64Decode(str: string): Uint8Array {
+  const isUrlSafe = str.includes("-") || str.includes("_");
+  const hasPadding = str.includes("=");
+
+  if (isUrlSafe) {
+    return hasPadding ? base64url.decode(str) : base64urlnopad.decode(str);
+  }
+  return hasPadding ? base64.decode(str) : base64nopad.decode(str);
+}
+
+export async function getContentPublicKey(): Promise<PublicKey> {
+  return await getPublicKeyFixed(CONTENT_KEY_TAG).catch(() => {
+    return generate(CONTENT_KEY_TAG);
+  });
+}
+
+export function getSecureEnclaveKeyId(publicKey: ECKey): Uint8Array {
+  if (publicKey.kty === "EC") {
+    const x = flexibleBase64Decode(publicKey.x);
+    const y = flexibleBase64Decode(publicKey.y);
+
+    const out = new Uint8Array(1 + x.length + y.length);
+    out[0] = 0x04; // uncompressed point format
+    out.set(x, 1);
+    out.set(y, 1 + x.length);
+
+    return sha1(out);
+  } else {
+    throw "Invalid key type";
+  }
+}

package/src/generated/zcam1_c2pa_utils-ffi.ts

@@ -0,0 +1,456 @@
+// 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 {
+  type StructuralEquality as UniffiStructuralEquality,
+  type UniffiForeignFuture as RuntimeUniffiForeignFuture,
+  type UniffiRustCallStatus,
+  type UniffiRustArcPtr,
+  type UniffiRustFutureContinuationCallback as RuntimeUniffiRustFutureContinuationCallback,
+  type UniffiResult,
+} from "uniffi-bindgen-react-native";
+
+interface NativeModuleInterface {
+  ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(
+    string: string,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_uniffi_internal_fn_func_ffi__string_to_arraybuffer(
+    string: string,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): Uint8Array;
+  ubrn_uniffi_internal_fn_func_ffi__arraybuffer_to_string(
+    buffer: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): string;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_clone_manifest(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_free_manifest(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): void;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifest_bindings(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): Uint8Array;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifest_capture_metadata_action(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): Uint8Array;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifest_proof(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): Uint8Array;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_clone_manifesteditor(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_free_manifesteditor(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): void;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_constructor_manifesteditor_from_manifest(
+    path: Uint8Array,
+    keyTag: Uint8Array,
+    certs: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_constructor_manifesteditor_new(
+    path: Uint8Array,
+    keyTag: Uint8Array,
+    certs: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_add_assertion(
+    ptr: bigint,
+    label: Uint8Array,
+    data: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): void;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_add_photo_metadata_action(
+    ptr: bigint,
+    parameters: Uint8Array,
+    when: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): Uint8Array;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_add_title(
+    ptr: bigint,
+    title: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): void;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_add_video_metadata_action(
+    ptr: bigint,
+    parameters: Uint8Array,
+    when: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): Uint8Array;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_embed_manifest_to_file(
+    ptr: bigint,
+    destination: Uint8Array,
+    format: Uint8Array,
+  ): bigint;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_remove_assertion(
+    ptr: bigint,
+    label: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_clone_manifeststore(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_free_manifeststore(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): void;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifeststore_active_manifest(
+    ptr: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_func_authenticity_status(path: Uint8Array): bigint;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_func_compute_hash(
+    path: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): Uint8Array;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_func_compute_hash_from_buffer(
+    buffer: Uint8Array,
+    format: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): Uint8Array;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_func_extract_manifest(
+    path: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint;
+  ubrn_uniffi_zcam1_c2pa_utils_fn_func_format_from_path(
+    path: Uint8Array,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): Uint8Array;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_u8(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_u8(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_u8(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_u8(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_i8(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_i8(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_i8(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_i8(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_u16(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_u16(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_u16(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_u16(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_i16(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_i16(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_i16(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_i16(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_u32(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_u32(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_u32(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_u32(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_i32(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_i32(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_i32(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_i32(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_u64(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_u64(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_u64(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_u64(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_i64(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_i64(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_i64(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_i64(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_f32(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_f32(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_f32(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_f32(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_f64(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_f64(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_f64(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_f64(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): number;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_pointer(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_pointer(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_pointer(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_pointer(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): bigint;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_rust_buffer(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_rust_buffer(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_rust_buffer(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_rust_buffer(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): Uint8Array;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_void(
+    handle: bigint,
+    callback: UniffiRustFutureContinuationCallback,
+    callbackData: bigint,
+  ): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_void(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_free_void(handle: bigint): void;
+  ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_void(
+    handle: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): void;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_func_authenticity_status(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_func_compute_hash(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_func_compute_hash_from_buffer(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_func_extract_manifest(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_func_format_from_path(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifest_bindings(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifest_capture_metadata_action(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifest_proof(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_assertion(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_photo_metadata_action(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_title(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_video_metadata_action(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_embed_manifest_to_file(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_remove_assertion(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifeststore_active_manifest(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_constructor_manifesteditor_from_manifest(): number;
+  ubrn_uniffi_zcam1_c2pa_utils_checksum_constructor_manifesteditor_new(): number;
+  ubrn_ffi_zcam1_c2pa_utils_uniffi_contract_version(): number;
+  ubrn_uniffi_internal_fn_method_manifest_ffi__bless_pointer(
+    pointer: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): UniffiRustArcPtr;
+  ubrn_uniffi_internal_fn_method_manifesteditor_ffi__bless_pointer(
+    pointer: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): UniffiRustArcPtr;
+  ubrn_uniffi_internal_fn_method_manifeststore_ffi__bless_pointer(
+    pointer: bigint,
+    uniffi_out_err: UniffiRustCallStatus,
+  ): UniffiRustArcPtr;
+}
+
+// Casting globalThis to any allows us to look for `NativeZcam1C2paUtils`
+// if it was added via JSI.
+//
+// We use a getter here rather than simply `globalThis.NativeZcam1C2paUtils` so that
+// if/when the startup sequence isn't just so, an empty value isn't inadvertantly cached.
+const getter: () => NativeModuleInterface = () => (globalThis as any).NativeZcam1C2paUtils;
+export default getter;
+
+// Structs and function types for calling back into Typescript from Rust.
+export type UniffiRustFutureContinuationCallback = (data: bigint, pollResult: number) => void;
+type UniffiForeignFutureFree = (handle: bigint) => void;
+type UniffiCallbackInterfaceFree = (handle: bigint) => void;
+export type UniffiForeignFuture = {
+  handle: bigint;
+  free: UniffiForeignFutureFree;
+};
+export type UniffiForeignFutureStructU8 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteU8 = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructU8,
+) => void;
+export type UniffiForeignFutureStructI8 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteI8 = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructI8,
+) => void;
+export type UniffiForeignFutureStructU16 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteU16 = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructU16,
+) => void;
+export type UniffiForeignFutureStructI16 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteI16 = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructI16,
+) => void;
+export type UniffiForeignFutureStructU32 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteU32 = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructU32,
+) => void;
+export type UniffiForeignFutureStructI32 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteI32 = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructI32,
+) => void;
+export type UniffiForeignFutureStructU64 = {
+  returnValue: bigint;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteU64 = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructU64,
+) => void;
+export type UniffiForeignFutureStructI64 = {
+  returnValue: bigint;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteI64 = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructI64,
+) => void;
+export type UniffiForeignFutureStructF32 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteF32 = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructF32,
+) => void;
+export type UniffiForeignFutureStructF64 = {
+  returnValue: number;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteF64 = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructF64,
+) => void;
+export type UniffiForeignFutureStructPointer = {
+  returnValue: bigint;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompletePointer = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructPointer,
+) => void;
+export type UniffiForeignFutureStructRustBuffer = {
+  returnValue: Uint8Array;
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteRustBuffer = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructRustBuffer,
+) => void;
+export type UniffiForeignFutureStructVoid = {
+  callStatus: UniffiRustCallStatus;
+};
+export type UniffiForeignFutureCompleteVoid = (
+  callbackData: bigint,
+  result: UniffiForeignFutureStructVoid,
+) => void;
+
+// UniffiRustFutureContinuationCallback is generated as part of the component interface's
+// ffi_definitions. However, we need it in the runtime.
+// We could:
+// (a) do some complicated template logic to ensure the declaration is not generated here (possible)
+// (b) import the generated declaration into the runtime (m a y b e) or…
+// (c) generate the declaration anyway, and use a different declaration in the runtime.
+//
+// We chose (c) here as the simplest. In addition, we perform a compile time check that
+// the two versions of `UniffiRustFutureContinuationCallback` are structurally equivalent.
+//
+// If you see the error:
+// ```
+// Type 'true' is not assignable to type 'false'.(2322)
+// ```
+// Then a new version of uniffi has changed the signature of the callback. Most likely, code in
+// `typescript/src/async-rust-call.ts` will need to be changed.
+//
+// If you see the error:
+// ```
+// Cannot find name 'UniffiRustFutureContinuationCallback'. Did you mean 'RuntimeUniffiRustFutureContinuationCallback'?(2552)
+// ```
+// then you may not be using callbacks or promises, and uniffi is now not generating Futures and callbacks.
+// You should not generate this if that is the case.
+//
+// ('You' being the bindings generator maintainer).
+const isRustFutureContinuationCallbackTypeCompatible: UniffiStructuralEquality<
+  RuntimeUniffiRustFutureContinuationCallback,
+  UniffiRustFutureContinuationCallback
+> = true;
+const isUniffiForeignFutureTypeCompatible: UniffiStructuralEquality<
+  RuntimeUniffiForeignFuture,
+  UniffiForeignFuture
+> = true;