@succinctlabs/react-native-zcam1 0.2.7 → 0.3.13

package/src/camera.tsx

@@ -1,14 +1,17 @@
+import Geolocation from "@react-native-community/geolocation";
 import JailMonkey from "jail-monkey";
 import React from "react";
 import { requireNativeComponent, type StyleProp, type ViewStyle } from "react-native";
-import { Dirs, Util } from "react-native-file-access";
+import { Dirs, FileSystem, Util } from "react-native-file-access";
 
 import {
+  AuthenticityData,
   buildSelfSignedCertificate,
   computeHash,
   DepthData,
   ExistingCertChain,
   formatFromPath,
+  LocationInfo,
   ManifestEditor,
   type PhotoMetadataInfo,
   SelfSignedCertChain,
@@ -43,6 +46,13 @@ export type CaptureFormat = "jpeg" | "dng";
  */
 export type CameraFilmStyle = "normal" | "mellow" | "nostalgic" | "bw";
 
+/**
+ * Hardware shutter action type.
+ * - "photo": Full press on volume button or Camera Control. Trigger capture.
+ * - "focus": Light press on Camera Control. Trigger focus/zoom (optional).
+ */
+export type HardwareShutterAction = "photo" | "focus";
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Custom Film Style Recipe Types
 // ─────────────────────────────────────────────────────────────────────────────
@@ -153,6 +163,22 @@ export interface ZCameraProps {
    * Use with `filmStyle` prop by casting the custom name: `filmStyle={"myStyle" as CameraFilmStyle}`.
    */
   customFilmStyles?: Record<string, FilmStyleRecipe>;
+  /**
+   * When true, embeds a trusted GPS timestamp in the C2PA manifest at capture time.
+   * Requires location permission. The timestamp is sourced from GPS rather than device clock,
+   * making it tamper-evident. Stored as `trustedTimestamp` in photo/video metadata.
+   * @default false
+   */
+  captureTimestampEnabled?: boolean;
+  /**
+   * When true, embeds GPS coordinates in the C2PA manifest at capture time.
+   * Requires location permission. Stored as `location` in photo/video metadata.
+   * If location retrieval fails, `isLocationAvailable` is set to `false` and
+   * `locationRetrievalStatus` contains the error reason.
+   * @default false
+   */
+  captureLocationEnabled?: boolean;
+
   /**
    * Enable depth data capture at session level.
    * When true, depth data can be captured but zoom may be restricted on dual-camera devices.
@@ -167,6 +193,21 @@ export interface ZCameraProps {
    * @param orientation The new physical orientation of the device.
    */
   onOrientationChange?: (orientation: DeviceOrientation) => void;
+  /**
+   * Whether hardware buttons (volume buttons, Camera Control on iPhone 16)
+   * should trigger capture events via onHardwareShutter.
+   * When enabled, the system volume HUD is automatically suppressed while
+   * the camera is active. Requires iOS 17.2+; ignored on older versions.
+   * @default true
+   */
+  hardwareShutterEnabled?: boolean;
+  /**
+   * Callback fired when a hardware capture button is pressed.
+   * Volume buttons and Camera Control (iPhone 16) trigger "photo" action.
+   * Light press on Camera Control triggers "focus" action.
+   * @param action The type of hardware shutter event.
+   */
+  onHardwareShutter?: (action: HardwareShutterAction) => void;
   /** Capture information used to generate C2PA bindings for each photo. */
   captureInfo: CaptureInfo;
   /** Optional certificate chain used to sign the C2PA manifest. */
@@ -206,6 +247,8 @@ type NativeCameraViewProps = {
   customFilmStyles?: Record<string, FilmStyleEffect[]>;
   depthEnabled?: boolean;
   onOrientationChange?: (event: { nativeEvent: { orientation: string } }) => void;
+  hardwareShutterEnabled?: boolean;
+  onHardwareShutter?: (event: { nativeEvent: { action: string } }) => void;
 };
 
 /**
@@ -472,6 +515,16 @@ export class ZCamera extends React.PureComponent<ZCameraProps> {
       const when = new Date().toISOString().replace("T", " ").split(".")[0]!;
       const isJailBroken = JailMonkey.isJailBroken();
       const isLocationSpoofingAvailable = JailMonkey.canMockLocation();
+      const location = await retrieveLocationData(
+        this.props.captureTimestampEnabled,
+        this.props.captureLocationEnabled,
+      );
+      const authenticityData: AuthenticityData = {
+        isJailBroken,
+        isLocationSpoofingAvailable,
+        isLocationAvailable: location.isLocationAvailable,
+        locationRetrievalStatus: location.locationRetrievalStatus,
+      };
 
       result.filePath = await embedBindings(
         result.filePath,
@@ -492,11 +545,10 @@ export class ZCamera extends React.PureComponent<ZCameraProps> {
           audioCodec: result.audioCodec,
           audioSampleRate: result.audioSampleRate,
           audioChannels: result.audioChannels,
-          authenticityData: {
-            isJailBroken,
-            isLocationSpoofingAvailable,
-          },
+          authenticityData,
           filmStyle: this.resolveFilmStyleInfo(),
+          trustedTimestamp: location.trustedTimestamp,
+          location: location.coords,
         },
         this.props.captureInfo,
         this.certChainPem,
@@ -543,6 +595,15 @@ export class ZCamera extends React.PureComponent<ZCameraProps> {
     }
 
     const originalPath = result.filePath;
+    const depthHeatMapPath = result.depthHeatMapPath as string | undefined;
+    const depthRawHash = result.depthRawHash as string | undefined;
+
+    // Log depth diagnostics for troubleshooting.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const depthDiag = (result as any)._depthDiag;
+    if (depthDiag) {
+      console.log("[DEPTH_DIAG]", JSON.stringify(depthDiag, null, 2));
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const metadata = (result.metadata as any) ?? {};
 
@@ -555,6 +616,16 @@ export class ZCamera extends React.PureComponent<ZCameraProps> {
     const softwareVersion = tiff.Software || "Unknown";
     const isJailBroken = JailMonkey.isJailBroken();
     const isLocationSpoofingAvailable = JailMonkey.canMockLocation();
+    const location = await retrieveLocationData(
+      this.props.captureTimestampEnabled,
+      this.props.captureLocationEnabled,
+    );
+    const authenticityData: AuthenticityData = {
+      isJailBroken,
+      isLocationSpoofingAvailable,
+      isLocationAvailable: location.isLocationAvailable,
+      locationRetrievalStatus: location.locationRetrievalStatus,
+    };
 
     const destinationPath = await embedBindings(
       originalPath,
@@ -570,15 +641,16 @@ export class ZCamera extends React.PureComponent<ZCameraProps> {
         exposureTime: exif.ExposureTime,
         depthOfField: exif.FNumber,
         focalLength: exif.FocalLength,
-        authenticityData: {
-          isJailBroken,
-          isLocationSpoofingAvailable,
-        },
+        authenticityData,
         depthData: result.depthData as DepthData | undefined,
         filmStyle: this.resolveFilmStyleInfo(),
+        trustedTimestamp: location.trustedTimestamp,
+        location: location.coords,
       },
       this.props.captureInfo,
       this.certChainPem,
+      depthHeatMapPath,
+      depthRawHash,
     );
 
     return new ZPhoto(originalPath, destinationPath);
@@ -601,6 +673,8 @@ export class ZCamera extends React.PureComponent<ZCameraProps> {
       customFilmStyles,
       depthEnabled = false,
       onOrientationChange,
+      hardwareShutterEnabled = true,
+      onHardwareShutter,
       style,
     } = this.props;
 
@@ -629,6 +703,12 @@ export class ZCamera extends React.PureComponent<ZCameraProps> {
             ? (event) => onOrientationChange(event.nativeEvent.orientation as DeviceOrientation)
             : undefined
         }
+        hardwareShutterEnabled={hardwareShutterEnabled}
+        onHardwareShutter={
+          onHardwareShutter
+            ? (event) => onHardwareShutter(event.nativeEvent.action as HardwareShutterAction)
+            : undefined
+        }
       />
     );
   }
@@ -643,6 +723,8 @@ async function embedBindings(
   metadata: PhotoMetadataInfo | VideoMetadataInfo,
   captureInfo: CaptureInfo,
   certChainPem: string,
+  depthHeatMapPath?: string,
+  depthRawHash?: string,
 ): Promise<string> {
   originalPath = stripFileProtocol(originalPath);
   const dataHash = computeHash(originalPath);
@@ -670,10 +752,40 @@ async function embedBindings(
     normalizedMetadata = manifestEditor.addVideoMetadataAction(metadata as VideoMetadataInfo, when);
   }
 
+  // Embed depth heat map as a C2PA assertion if available.
+  // The heat map JPEG is read from disk (written by Swift during capture) — only the
+  // file path string crosses the RN bridge, not the binary data.
+  if (depthHeatMapPath && format.indexOf("video") < 0) {
+    try {
+      const heatMapBase64 = await FileSystem.readFile(depthHeatMapPath, "base64");
+      const depthData = (metadata as PhotoMetadataInfo).depthData;
+      manifestEditor.addAssertion(
+        "succinct.depth-heatmap",
+        JSON.stringify({
+          format: "image/jpeg",
+          width: depthData?.width,
+          height: depthData?.height,
+          colormap: "turbo",
+          depth_accuracy: depthData?.accuracy,
+          depth_range_min: depthData?.statistics?.min,
+          depth_range_max: depthData?.statistics?.max,
+          sensor_type: depthData?.pixelFormat,
+          raw_depth_hash: depthRawHash,
+          image_data: heatMapBase64,
+        }),
+      );
+    } catch (e) {
+      console.warn("[embedBindings] Failed to embed depth heat map:", e);
+    } finally {
+      FileSystem.unlink(depthHeatMapPath).catch(() => {});
+    }
+  }
+
   const assertion = await generateAppAttestAssertion(
     dataHash,
     normalizedMetadata,
     captureInfo.deviceKeyId,
+    captureInfo.production,
   );
 
   // Add an assertion containing all data needed to later generate a  proof
@@ -692,3 +804,61 @@ async function embedBindings(
 
   return destinationPath;
 }
+
+type LocationData = {
+  coords: LocationInfo | undefined;
+  trustedTimestamp: bigint | undefined;
+  isLocationAvailable: boolean | undefined;
+  locationRetrievalStatus: string | undefined;
+};
+
+function retrieveLocationData(
+  captureTimestampEnabled: boolean | undefined,
+  captureLocationEnabled: boolean | undefined,
+): Promise<LocationData> {
+  if (!captureTimestampEnabled && !captureLocationEnabled) {
+    return Promise.resolve({
+      coords: undefined,
+      trustedTimestamp: undefined,
+      isLocationAvailable: undefined,
+      locationRetrievalStatus: undefined,
+    });
+  }
+
+  return new Promise((resolve) => {
+    Geolocation.getCurrentPosition(
+      (position) => {
+        resolve({
+          coords: captureLocationEnabled
+            ? {
+                latitude: position.coords.latitude.toFixed(6),
+                longitude: position.coords.longitude.toFixed(6),
+                altitude: position.coords.altitude?.toFixed(6),
+                accuracy: position.coords.accuracy.toFixed(6),
+                altitudeAccuracy: position.coords.altitudeAccuracy?.toFixed(6),
+              }
+            : undefined,
+          trustedTimestamp: captureTimestampEnabled
+            ? BigInt(Math.trunc(position.timestamp))
+            : undefined,
+          isLocationAvailable: true,
+          locationRetrievalStatus: "success",
+        });
+      },
+      (error) => {
+        console.warn(`[ZCAM1] failed to retrieve GPS location data: ${error.message}`);
+        resolve({
+          coords: undefined,
+          trustedTimestamp: undefined,
+          isLocationAvailable: false,
+          locationRetrievalStatus: error.message,
+        });
+      },
+      {
+        timeout: 1000, // 1 second
+        maximumAge: 60 * 1000, // 1 minute
+        enableHighAccuracy: true,
+      },
+    );
+  });
+}

package/src/capture.tsx

@@ -1,4 +1,5 @@
 import { generateHardwareKey, getAttestation } from "@pagopa/io-react-native-integrity";
+import Geolocation from "@react-native-community/geolocation";
 import EncryptedStorage from "react-native-encrypted-storage";
 
 import { type ECKey, getContentPublicKey, getSecureEnclaveKeyId } from "./common";
@@ -51,6 +52,7 @@ export type {
  */
 export type CaptureInfo = {
   appId: string;
+  production: boolean;
   deviceKeyId: string;
   contentPublicKey: ECKey;
   contentKeyId: Uint8Array;
@@ -102,6 +104,12 @@ export async function initCapture(settings: Settings): Promise<CaptureInfo> {
       // 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")) {
+        if (settings.production) {
+          throw new Error(
+            "ZCAM: Simulator is not supported in production mode. Set production: false for development.",
+          );
+        }
+
         console.warn(
           "[ZCAM] Running in simulator - using mock device key. This is for development only.",
         );
@@ -126,6 +134,7 @@ export async function initCapture(settings: Settings): Promise<CaptureInfo> {
 
   return {
     appId: settings.appId,
+    production: settings.production,
     deviceKeyId,
     contentPublicKey,
     contentKeyId,
@@ -139,8 +148,8 @@ export async function initCapture(settings: Settings): Promise<CaptureInfo> {
  * @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
+export async function updateRegistration(keyId: string, settings: Settings): Promise<string> {
+  // Try to get real attestation, but fall back to mock for simulator in dev mode
   let attestation: string;
   try {
     attestation = await getAttestation(keyId, keyId);
@@ -148,11 +157,15 @@ export async function updateRegistration(keyId: string, _settings: Settings): Pr
     // 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")) {
+      if (settings.production) {
+        throw new Error(
+          "ZCAM: Simulator is not supported in production mode. Set production: false for development.",
+        );
+      }
       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;
@@ -163,3 +176,17 @@ export async function updateRegistration(keyId: string, _settings: Settings): Pr
 
   return attestation;
 }
+
+/**
+ * Requests location permission from the user.
+ * This function triggers the native location authorization prompt on the device.
+ * @throws {string} Error message if permission request fails
+ */
+export function requestLocationPermission() {
+  Geolocation.requestAuthorization(
+    () => {},
+    (error) => {
+      throw error.message;
+    },
+  );
+}

package/src/common.tsx

@@ -24,8 +24,9 @@ function flexibleBase64Decode(str: string): Uint8Array {
 }
 
 export async function getContentPublicKey(): Promise<PublicKey> {
-  return await getPublicKeyFixed(CONTENT_KEY_TAG).catch(() => {
-    return generate(CONTENT_KEY_TAG);
+  return await getPublicKeyFixed(CONTENT_KEY_TAG).catch(async () => {
+    await generate(CONTENT_KEY_TAG);
+    return getPublicKeyFixed(CONTENT_KEY_TAG);
   });
 }
 

package/src/generated/zcam1_c2pa_utils.ts

@@ -169,6 +169,8 @@ export function formatFromPath(path: string): string | undefined {
 export type AuthenticityData = {
   isJailBroken: boolean;
   isLocationSpoofingAvailable: boolean;
+  isLocationAvailable: boolean | undefined;
+  locationRetrievalStatus: string | undefined;
 };
 
 /**
@@ -206,16 +208,22 @@ const FfiConverterTypeAuthenticityData = (() => {
       return {
         isJailBroken: FfiConverterBool.read(from),
         isLocationSpoofingAvailable: FfiConverterBool.read(from),
+        isLocationAvailable: FfiConverterOptionalBool.read(from),
+        locationRetrievalStatus: FfiConverterOptionalString.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
       FfiConverterBool.write(value.isJailBroken, into);
       FfiConverterBool.write(value.isLocationSpoofingAvailable, into);
+      FfiConverterOptionalBool.write(value.isLocationAvailable, into);
+      FfiConverterOptionalString.write(value.locationRetrievalStatus, into);
     }
     allocationSize(value: TypeName): number {
       return (
         FfiConverterBool.allocationSize(value.isJailBroken) +
-        FfiConverterBool.allocationSize(value.isLocationSpoofingAvailable)
+        FfiConverterBool.allocationSize(value.isLocationSpoofingAvailable) +
+        FfiConverterOptionalBool.allocationSize(value.isLocationAvailable) +
+        FfiConverterOptionalString.allocationSize(value.locationRetrievalStatus)
       );
     }
   }
@@ -605,6 +613,95 @@ const FfiConverterTypeFilmStyleInfo = (() => {
   return new FFIConverter();
 })();
 
+/**
+ * GPS location captured at the time of photo/video creation.
+ *
+ * Coordinates and accuracy are stored as strings to preserve the original
+ * precision from the device without floating-point rounding.
+ */
+export type LocationInfo = {
+  /**
+   * Latitude in decimal degrees (e.g. "37.7749").
+   */
+  latitude: string;
+  /**
+   * Longitude in decimal degrees (e.g. "-122.4194").
+   */
+  longitude: string;
+  /**
+   * Altitude in meters above sea level, if available.
+   */
+  altitude: string | undefined;
+  /**
+   * Horizontal accuracy radius in meters.
+   */
+  accuracy: string;
+  /**
+   * Vertical accuracy in meters, if available.
+   */
+  altitudeAccuracy: string | undefined;
+};
+
+/**
+ * Generated factory for {@link LocationInfo} record objects.
+ */
+export const LocationInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<LocationInfo, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link LocationInfo}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link LocationInfo}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    new: create,
+
+    /**
+     * Defaults specified in the {@link zcam1_c2pa_utils} crate.
+     */
+    defaults: () => Object.freeze(defaults()) as Partial<LocationInfo>,
+  });
+})();
+
+const FfiConverterTypeLocationInfo = (() => {
+  type TypeName = LocationInfo;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        latitude: FfiConverterString.read(from),
+        longitude: FfiConverterString.read(from),
+        altitude: FfiConverterOptionalString.read(from),
+        accuracy: FfiConverterString.read(from),
+        altitudeAccuracy: FfiConverterOptionalString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.latitude, into);
+      FfiConverterString.write(value.longitude, into);
+      FfiConverterOptionalString.write(value.altitude, into);
+      FfiConverterString.write(value.accuracy, into);
+      FfiConverterOptionalString.write(value.altitudeAccuracy, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.latitude) +
+        FfiConverterString.allocationSize(value.longitude) +
+        FfiConverterOptionalString.allocationSize(value.altitude) +
+        FfiConverterString.allocationSize(value.accuracy) +
+        FfiConverterOptionalString.allocationSize(value.altitudeAccuracy)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
 export type PhotoMetadataInfo = {
   deviceMake: string;
   deviceModel: string;
@@ -619,6 +716,8 @@ export type PhotoMetadataInfo = {
   authenticityData: AuthenticityData;
   depthData: DepthData | undefined;
   filmStyle: FilmStyleInfo | undefined;
+  trustedTimestamp: /*u64*/ bigint | undefined;
+  location: LocationInfo | undefined;
 };
 
 /**
@@ -667,6 +766,8 @@ const FfiConverterTypePhotoMetadataInfo = (() => {
         authenticityData: FfiConverterTypeAuthenticityData.read(from),
         depthData: FfiConverterOptionalTypeDepthData.read(from),
         filmStyle: FfiConverterOptionalTypeFilmStyleInfo.read(from),
+        trustedTimestamp: FfiConverterOptionalUInt64.read(from),
+        location: FfiConverterOptionalTypeLocationInfo.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
@@ -683,6 +784,8 @@ const FfiConverterTypePhotoMetadataInfo = (() => {
       FfiConverterTypeAuthenticityData.write(value.authenticityData, into);
       FfiConverterOptionalTypeDepthData.write(value.depthData, into);
       FfiConverterOptionalTypeFilmStyleInfo.write(value.filmStyle, into);
+      FfiConverterOptionalUInt64.write(value.trustedTimestamp, into);
+      FfiConverterOptionalTypeLocationInfo.write(value.location, into);
     }
     allocationSize(value: TypeName): number {
       return (
@@ -698,7 +801,9 @@ const FfiConverterTypePhotoMetadataInfo = (() => {
         FfiConverterUInt32.allocationSize(value.focalLength) +
         FfiConverterTypeAuthenticityData.allocationSize(value.authenticityData) +
         FfiConverterOptionalTypeDepthData.allocationSize(value.depthData) +
-        FfiConverterOptionalTypeFilmStyleInfo.allocationSize(value.filmStyle)
+        FfiConverterOptionalTypeFilmStyleInfo.allocationSize(value.filmStyle) +
+        FfiConverterOptionalUInt64.allocationSize(value.trustedTimestamp) +
+        FfiConverterOptionalTypeLocationInfo.allocationSize(value.location)
       );
     }
   }
@@ -779,6 +884,8 @@ export type VideoMetadataInfo = {
   audioChannels: /*u32*/ number | undefined;
   authenticityData: AuthenticityData;
   filmStyle: FilmStyleInfo | undefined;
+  trustedTimestamp: /*u64*/ bigint | undefined;
+  location: LocationInfo | undefined;
 };
 
 /**
@@ -831,6 +938,8 @@ const FfiConverterTypeVideoMetadataInfo = (() => {
         audioChannels: FfiConverterOptionalUInt32.read(from),
         authenticityData: FfiConverterTypeAuthenticityData.read(from),
         filmStyle: FfiConverterOptionalTypeFilmStyleInfo.read(from),
+        trustedTimestamp: FfiConverterOptionalUInt64.read(from),
+        location: FfiConverterOptionalTypeLocationInfo.read(from),
       };
     }
     write(value: TypeName, into: RustBuffer): void {
@@ -851,6 +960,8 @@ const FfiConverterTypeVideoMetadataInfo = (() => {
       FfiConverterOptionalUInt32.write(value.audioChannels, into);
       FfiConverterTypeAuthenticityData.write(value.authenticityData, into);
       FfiConverterOptionalTypeFilmStyleInfo.write(value.filmStyle, into);
+      FfiConverterOptionalUInt64.write(value.trustedTimestamp, into);
+      FfiConverterOptionalTypeLocationInfo.write(value.location, into);
     }
     allocationSize(value: TypeName): number {
       return (
@@ -870,7 +981,9 @@ const FfiConverterTypeVideoMetadataInfo = (() => {
         FfiConverterOptionalUInt32.allocationSize(value.audioSampleRate) +
         FfiConverterOptionalUInt32.allocationSize(value.audioChannels) +
         FfiConverterTypeAuthenticityData.allocationSize(value.authenticityData) +
-        FfiConverterOptionalTypeFilmStyleInfo.allocationSize(value.filmStyle)
+        FfiConverterOptionalTypeFilmStyleInfo.allocationSize(value.filmStyle) +
+        FfiConverterOptionalUInt64.allocationSize(value.trustedTimestamp) +
+        FfiConverterOptionalTypeLocationInfo.allocationSize(value.location)
       );
     }
   }
@@ -1683,6 +1796,9 @@ const uniffiTypeManifestStoreObjectFactory: UniffiObjectFactory<ManifestStoreInt
 // FfiConverter for ManifestStoreInterface
 const FfiConverterTypeManifestStore = new FfiConverterObject(uniffiTypeManifestStoreObjectFactory);
 
+// FfiConverter for boolean | undefined
+const FfiConverterOptionalBool = new FfiConverterOptional(FfiConverterBool);
+
 // FfiConverter for DepthData | undefined
 const FfiConverterOptionalTypeDepthData = new FfiConverterOptional(FfiConverterTypeDepthData);
 
@@ -1696,6 +1812,9 @@ const FfiConverterOptionalTypeFilmStyleInfo = new FfiConverterOptional(
   FfiConverterTypeFilmStyleInfo,
 );
 
+// FfiConverter for LocationInfo | undefined
+const FfiConverterOptionalTypeLocationInfo = new FfiConverterOptional(FfiConverterTypeLocationInfo);
+
 // FfiConverter for Proof | undefined
 const FfiConverterOptionalTypeProof = new FfiConverterOptional(FfiConverterTypeProof);
 
@@ -1705,6 +1824,9 @@ const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
 // FfiConverter for /*u32*/number | undefined
 const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
 
+// FfiConverter for /*u64*/bigint | undefined
+const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
+
 /**
  * This should be called before anything else.
  *
@@ -1856,6 +1978,7 @@ export default Object.freeze({
     FfiConverterTypeDeviceBindings,
     FfiConverterTypeExclusion,
     FfiConverterTypeFilmStyleInfo,
+    FfiConverterTypeLocationInfo,
     FfiConverterTypeManifest,
     FfiConverterTypeManifestEditor,
     FfiConverterTypeManifestStore,