@succinctlabs/react-native-zcam1 0.2.5

package/src/generated/zcam1_c2pa_utils.ts

@@ -0,0 +1,1866 @@
+// 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, {
+  type UniffiRustFutureContinuationCallback,
+  type UniffiForeignFuture,
+  type UniffiForeignFutureStructU8,
+  type UniffiForeignFutureCompleteU8,
+  type UniffiForeignFutureStructI8,
+  type UniffiForeignFutureCompleteI8,
+  type UniffiForeignFutureStructU16,
+  type UniffiForeignFutureCompleteU16,
+  type UniffiForeignFutureStructI16,
+  type UniffiForeignFutureCompleteI16,
+  type UniffiForeignFutureStructU32,
+  type UniffiForeignFutureCompleteU32,
+  type UniffiForeignFutureStructI32,
+  type UniffiForeignFutureCompleteI32,
+  type UniffiForeignFutureStructU64,
+  type UniffiForeignFutureCompleteU64,
+  type UniffiForeignFutureStructI64,
+  type UniffiForeignFutureCompleteI64,
+  type UniffiForeignFutureStructF32,
+  type UniffiForeignFutureCompleteF32,
+  type UniffiForeignFutureStructF64,
+  type UniffiForeignFutureCompleteF64,
+  type UniffiForeignFutureStructPointer,
+  type UniffiForeignFutureCompletePointer,
+  type UniffiForeignFutureStructRustBuffer,
+  type UniffiForeignFutureCompleteRustBuffer,
+  type UniffiForeignFutureStructVoid,
+  type UniffiForeignFutureCompleteVoid,
+} from "./zcam1_c2pa_utils-ffi";
+import {
+  type FfiConverter,
+  type UniffiByteArray,
+  type UniffiObjectFactory,
+  type UniffiRustArcPtr,
+  type UnsafeMutableRawPointer,
+  AbstractFfiConverterByteArray,
+  FfiConverterArrayBuffer,
+  FfiConverterBool,
+  FfiConverterInt32,
+  FfiConverterObject,
+  FfiConverterOptional,
+  FfiConverterUInt32,
+  FfiConverterUInt64,
+  RustBuffer,
+  UniffiAbstractObject,
+  UniffiError,
+  UniffiInternalError,
+  UniffiRustCaller,
+  destructorGuardSymbol,
+  pointerLiteralSymbol,
+  uniffiCreateFfiConverterString,
+  uniffiCreateRecord,
+  uniffiRustCallAsync,
+  uniffiTypeNameSymbol,
+  variantOrdinalSymbol,
+} from "uniffi-bindgen-react-native";
+
+// Get converters from the other files, if any.
+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.
+
+export async function authenticityStatus(
+  path: string,
+  asyncOpts_?: { signal: AbortSignal },
+): Promise<AuthenticityStatus> {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
+        return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_func_authenticity_status(
+          FfiConverterString.lower(path),
+        );
+      },
+      /*pollFunc:*/ nativeModule().ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_rust_buffer,
+      /*cancelFunc:*/ nativeModule().ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_rust_buffer,
+      /*completeFunc:*/ nativeModule().ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_rust_buffer,
+      /*freeFunc:*/ nativeModule().ubrn_ffi_zcam1_c2pa_utils_rust_future_free_rust_buffer,
+      /*liftFunc:*/ FfiConverterTypeAuthenticityStatus.lift.bind(
+        FfiConverterTypeAuthenticityStatus,
+      ),
+      /*liftString:*/ FfiConverterString.lift,
+      /*asyncOpts:*/ asyncOpts_,
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+/**
+ * Compute the hash for a file.
+ *
+ * Note: the file should **not** have a C2PA manifest embedded.
+ */
+export function computeHash(path: string): ArrayBuffer /*throws*/ {
+  return FfiConverterArrayBuffer.lift(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_func_compute_hash(
+          FfiConverterString.lower(path),
+          callStatus,
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    ),
+  );
+}
+export function computeHashFromBuffer(buffer: ArrayBuffer, format: string): ArrayBuffer /*throws*/ {
+  return FfiConverterArrayBuffer.lift(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_func_compute_hash_from_buffer(
+          FfiConverterArrayBuffer.lower(buffer),
+          FfiConverterString.lower(format),
+          callStatus,
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    ),
+  );
+}
+export function extractManifest(path: string): ManifestStoreInterface /*throws*/ {
+  return FfiConverterTypeManifestStore.lift(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_func_extract_manifest(
+          FfiConverterString.lower(path),
+          callStatus,
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    ),
+  );
+}
+/**
+ * Return a MIME type given a file path.
+ *
+ * This function will use the file extension to determine the MIME type.
+ */
+export function formatFromPath(path: string): string | undefined {
+  return FfiConverterOptionalString.lift(
+    uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_func_format_from_path(
+          FfiConverterString.lower(path),
+          callStatus,
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    ),
+  );
+}
+
+export type AuthenticityData = {
+  isJailBroken: boolean;
+  isLocationSpoofingAvailable: boolean;
+};
+
+/**
+ * Generated factory for {@link AuthenticityData} record objects.
+ */
+export const AuthenticityData = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<AuthenticityData, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link AuthenticityData}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link AuthenticityData}, 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<AuthenticityData>,
+  });
+})();
+
+const FfiConverterTypeAuthenticityData = (() => {
+  type TypeName = AuthenticityData;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        isJailBroken: FfiConverterBool.read(from),
+        isLocationSpoofingAvailable: FfiConverterBool.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterBool.write(value.isJailBroken, into);
+      FfiConverterBool.write(value.isLocationSpoofingAvailable, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterBool.allocationSize(value.isJailBroken) +
+        FfiConverterBool.allocationSize(value.isLocationSpoofingAvailable)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type Claim = {
+  signature: string;
+};
+
+/**
+ * Generated factory for {@link Claim} record objects.
+ */
+export const Claim = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<Claim, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link Claim}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link Claim}, 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<Claim>,
+  });
+})();
+
+const FfiConverterTypeClaim = (() => {
+  type TypeName = Claim;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        signature: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.signature, into);
+    }
+    allocationSize(value: TypeName): number {
+      return FfiConverterString.allocationSize(value.signature);
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type DepthData = {
+  width: /*u32*/ number;
+  height: /*u32*/ number;
+  pixelFormat: string;
+  statistics: DepthDataStatistics;
+  accuracy: string;
+};
+
+/**
+ * Generated factory for {@link DepthData} record objects.
+ */
+export const DepthData = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<DepthData, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link DepthData}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link DepthData}, 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<DepthData>,
+  });
+})();
+
+const FfiConverterTypeDepthData = (() => {
+  type TypeName = DepthData;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        width: FfiConverterUInt32.read(from),
+        height: FfiConverterUInt32.read(from),
+        pixelFormat: FfiConverterString.read(from),
+        statistics: FfiConverterTypeDepthDataStatistics.read(from),
+        accuracy: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt32.write(value.width, into);
+      FfiConverterUInt32.write(value.height, into);
+      FfiConverterString.write(value.pixelFormat, into);
+      FfiConverterTypeDepthDataStatistics.write(value.statistics, into);
+      FfiConverterString.write(value.accuracy, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt32.allocationSize(value.width) +
+        FfiConverterUInt32.allocationSize(value.height) +
+        FfiConverterString.allocationSize(value.pixelFormat) +
+        FfiConverterTypeDepthDataStatistics.allocationSize(value.statistics) +
+        FfiConverterString.allocationSize(value.accuracy)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type DepthDataStatistics = {
+  min: string;
+  max: string;
+  mean: string;
+  stdDev: string;
+  validPixelCount: /*u32*/ number;
+  sampleStride: /*u32*/ number;
+};
+
+/**
+ * Generated factory for {@link DepthDataStatistics} record objects.
+ */
+export const DepthDataStatistics = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<DepthDataStatistics, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link DepthDataStatistics}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link DepthDataStatistics}, 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<DepthDataStatistics>,
+  });
+})();
+
+const FfiConverterTypeDepthDataStatistics = (() => {
+  type TypeName = DepthDataStatistics;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        min: FfiConverterString.read(from),
+        max: FfiConverterString.read(from),
+        mean: FfiConverterString.read(from),
+        stdDev: FfiConverterString.read(from),
+        validPixelCount: FfiConverterUInt32.read(from),
+        sampleStride: FfiConverterUInt32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.min, into);
+      FfiConverterString.write(value.max, into);
+      FfiConverterString.write(value.mean, into);
+      FfiConverterString.write(value.stdDev, into);
+      FfiConverterUInt32.write(value.validPixelCount, into);
+      FfiConverterUInt32.write(value.sampleStride, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.min) +
+        FfiConverterString.allocationSize(value.max) +
+        FfiConverterString.allocationSize(value.mean) +
+        FfiConverterString.allocationSize(value.stdDev) +
+        FfiConverterUInt32.allocationSize(value.validPixelCount) +
+        FfiConverterUInt32.allocationSize(value.sampleStride)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type DeviceBindings = {
+  appId: string;
+  deviceKeyId: string;
+  attestation: string;
+  assertion: string;
+};
+
+/**
+ * Generated factory for {@link DeviceBindings} record objects.
+ */
+export const DeviceBindings = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<DeviceBindings, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link DeviceBindings}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link DeviceBindings}, 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<DeviceBindings>,
+  });
+})();
+
+const FfiConverterTypeDeviceBindings = (() => {
+  type TypeName = DeviceBindings;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        appId: FfiConverterString.read(from),
+        deviceKeyId: FfiConverterString.read(from),
+        attestation: FfiConverterString.read(from),
+        assertion: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.appId, into);
+      FfiConverterString.write(value.deviceKeyId, into);
+      FfiConverterString.write(value.attestation, into);
+      FfiConverterString.write(value.assertion, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.appId) +
+        FfiConverterString.allocationSize(value.deviceKeyId) +
+        FfiConverterString.allocationSize(value.attestation) +
+        FfiConverterString.allocationSize(value.assertion)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type Exclusion = {
+  start: /*u64*/ bigint;
+  length: /*u64*/ bigint;
+};
+
+/**
+ * Generated factory for {@link Exclusion} record objects.
+ */
+export const Exclusion = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<Exclusion, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link Exclusion}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link Exclusion}, 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<Exclusion>,
+  });
+})();
+
+const FfiConverterTypeExclusion = (() => {
+  type TypeName = Exclusion;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        start: FfiConverterUInt64.read(from),
+        length: FfiConverterUInt64.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterUInt64.write(value.start, into);
+      FfiConverterUInt64.write(value.length, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterUInt64.allocationSize(value.start) +
+        FfiConverterUInt64.allocationSize(value.length)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Film style (filter) information captured at the time of photo/video creation.
+ */
+export type FilmStyleInfo = {
+  /**
+   * Name of the film style (e.g. "mellow", "bw", or a custom name).
+   */
+  name: string;
+  /**
+   * Whether this is a built-in preset, an overridden preset, or a custom style.
+   * One of "builtin", "override", or "custom".
+   */
+  source: string;
+  /**
+   * The recipe that was applied, serialized as a JSON array of effects.
+   */
+  recipe: string;
+};
+
+/**
+ * Generated factory for {@link FilmStyleInfo} record objects.
+ */
+export const FilmStyleInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<FilmStyleInfo, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link FilmStyleInfo}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link FilmStyleInfo}, 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<FilmStyleInfo>,
+  });
+})();
+
+const FfiConverterTypeFilmStyleInfo = (() => {
+  type TypeName = FilmStyleInfo;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        name: FfiConverterString.read(from),
+        source: FfiConverterString.read(from),
+        recipe: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.name, into);
+      FfiConverterString.write(value.source, into);
+      FfiConverterString.write(value.recipe, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.name) +
+        FfiConverterString.allocationSize(value.source) +
+        FfiConverterString.allocationSize(value.recipe)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type PhotoMetadataInfo = {
+  deviceMake: string;
+  deviceModel: string;
+  softwareVersion: string;
+  xResolution: /*u32*/ number;
+  yResolution: /*u32*/ number;
+  orientation: /*u32*/ number;
+  iso: string;
+  exposureTime: /*u32*/ number;
+  depthOfField: /*u32*/ number;
+  focalLength: /*u32*/ number;
+  authenticityData: AuthenticityData;
+  depthData: DepthData | undefined;
+  filmStyle: FilmStyleInfo | undefined;
+};
+
+/**
+ * Generated factory for {@link PhotoMetadataInfo} record objects.
+ */
+export const PhotoMetadataInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<PhotoMetadataInfo, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link PhotoMetadataInfo}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link PhotoMetadataInfo}, 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<PhotoMetadataInfo>,
+  });
+})();
+
+const FfiConverterTypePhotoMetadataInfo = (() => {
+  type TypeName = PhotoMetadataInfo;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        deviceMake: FfiConverterString.read(from),
+        deviceModel: FfiConverterString.read(from),
+        softwareVersion: FfiConverterString.read(from),
+        xResolution: FfiConverterUInt32.read(from),
+        yResolution: FfiConverterUInt32.read(from),
+        orientation: FfiConverterUInt32.read(from),
+        iso: FfiConverterString.read(from),
+        exposureTime: FfiConverterUInt32.read(from),
+        depthOfField: FfiConverterUInt32.read(from),
+        focalLength: FfiConverterUInt32.read(from),
+        authenticityData: FfiConverterTypeAuthenticityData.read(from),
+        depthData: FfiConverterOptionalTypeDepthData.read(from),
+        filmStyle: FfiConverterOptionalTypeFilmStyleInfo.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.deviceMake, into);
+      FfiConverterString.write(value.deviceModel, into);
+      FfiConverterString.write(value.softwareVersion, into);
+      FfiConverterUInt32.write(value.xResolution, into);
+      FfiConverterUInt32.write(value.yResolution, into);
+      FfiConverterUInt32.write(value.orientation, into);
+      FfiConverterString.write(value.iso, into);
+      FfiConverterUInt32.write(value.exposureTime, into);
+      FfiConverterUInt32.write(value.depthOfField, into);
+      FfiConverterUInt32.write(value.focalLength, into);
+      FfiConverterTypeAuthenticityData.write(value.authenticityData, into);
+      FfiConverterOptionalTypeDepthData.write(value.depthData, into);
+      FfiConverterOptionalTypeFilmStyleInfo.write(value.filmStyle, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.deviceMake) +
+        FfiConverterString.allocationSize(value.deviceModel) +
+        FfiConverterString.allocationSize(value.softwareVersion) +
+        FfiConverterUInt32.allocationSize(value.xResolution) +
+        FfiConverterUInt32.allocationSize(value.yResolution) +
+        FfiConverterUInt32.allocationSize(value.orientation) +
+        FfiConverterString.allocationSize(value.iso) +
+        FfiConverterUInt32.allocationSize(value.exposureTime) +
+        FfiConverterUInt32.allocationSize(value.depthOfField) +
+        FfiConverterUInt32.allocationSize(value.focalLength) +
+        FfiConverterTypeAuthenticityData.allocationSize(value.authenticityData) +
+        FfiConverterOptionalTypeDepthData.allocationSize(value.depthData) +
+        FfiConverterOptionalTypeFilmStyleInfo.allocationSize(value.filmStyle)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type Proof = {
+  data: string;
+  vkHash: string;
+};
+
+/**
+ * Generated factory for {@link Proof} record objects.
+ */
+export const Proof = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<Proof, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link Proof}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link Proof}, 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<Proof>,
+  });
+})();
+
+const FfiConverterTypeProof = (() => {
+  type TypeName = Proof;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        data: FfiConverterString.read(from),
+        vkHash: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.data, into);
+      FfiConverterString.write(value.vkHash, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.data) +
+        FfiConverterString.allocationSize(value.vkHash)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type VideoMetadataInfo = {
+  deviceMake: string;
+  deviceModel: string;
+  softwareVersion: string;
+  format: string;
+  hasAudio: boolean;
+  durationSeconds: /*u32*/ number;
+  fileSizeBytes: /*u32*/ number;
+  width: /*u32*/ number;
+  height: /*u32*/ number;
+  rotationDegrees: /*u32*/ number;
+  frameRate: /*u32*/ number;
+  videoCodec: string | undefined;
+  audioCodec: string | undefined;
+  audioSampleRate: /*u32*/ number | undefined;
+  audioChannels: /*u32*/ number | undefined;
+  authenticityData: AuthenticityData;
+  filmStyle: FilmStyleInfo | undefined;
+};
+
+/**
+ * Generated factory for {@link VideoMetadataInfo} record objects.
+ */
+export const VideoMetadataInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<VideoMetadataInfo, ReturnType<typeof defaults>>(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link VideoMetadataInfo}, with defaults specified
+     * in Rust, in the {@link zcam1_c2pa_utils} crate.
+     */
+    create,
+
+    /**
+     * Create a frozen instance of {@link VideoMetadataInfo}, 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<VideoMetadataInfo>,
+  });
+})();
+
+const FfiConverterTypeVideoMetadataInfo = (() => {
+  type TypeName = VideoMetadataInfo;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        deviceMake: FfiConverterString.read(from),
+        deviceModel: FfiConverterString.read(from),
+        softwareVersion: FfiConverterString.read(from),
+        format: FfiConverterString.read(from),
+        hasAudio: FfiConverterBool.read(from),
+        durationSeconds: FfiConverterUInt32.read(from),
+        fileSizeBytes: FfiConverterUInt32.read(from),
+        width: FfiConverterUInt32.read(from),
+        height: FfiConverterUInt32.read(from),
+        rotationDegrees: FfiConverterUInt32.read(from),
+        frameRate: FfiConverterUInt32.read(from),
+        videoCodec: FfiConverterOptionalString.read(from),
+        audioCodec: FfiConverterOptionalString.read(from),
+        audioSampleRate: FfiConverterOptionalUInt32.read(from),
+        audioChannels: FfiConverterOptionalUInt32.read(from),
+        authenticityData: FfiConverterTypeAuthenticityData.read(from),
+        filmStyle: FfiConverterOptionalTypeFilmStyleInfo.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.deviceMake, into);
+      FfiConverterString.write(value.deviceModel, into);
+      FfiConverterString.write(value.softwareVersion, into);
+      FfiConverterString.write(value.format, into);
+      FfiConverterBool.write(value.hasAudio, into);
+      FfiConverterUInt32.write(value.durationSeconds, into);
+      FfiConverterUInt32.write(value.fileSizeBytes, into);
+      FfiConverterUInt32.write(value.width, into);
+      FfiConverterUInt32.write(value.height, into);
+      FfiConverterUInt32.write(value.rotationDegrees, into);
+      FfiConverterUInt32.write(value.frameRate, into);
+      FfiConverterOptionalString.write(value.videoCodec, into);
+      FfiConverterOptionalString.write(value.audioCodec, into);
+      FfiConverterOptionalUInt32.write(value.audioSampleRate, into);
+      FfiConverterOptionalUInt32.write(value.audioChannels, into);
+      FfiConverterTypeAuthenticityData.write(value.authenticityData, into);
+      FfiConverterOptionalTypeFilmStyleInfo.write(value.filmStyle, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.deviceMake) +
+        FfiConverterString.allocationSize(value.deviceModel) +
+        FfiConverterString.allocationSize(value.softwareVersion) +
+        FfiConverterString.allocationSize(value.format) +
+        FfiConverterBool.allocationSize(value.hasAudio) +
+        FfiConverterUInt32.allocationSize(value.durationSeconds) +
+        FfiConverterUInt32.allocationSize(value.fileSizeBytes) +
+        FfiConverterUInt32.allocationSize(value.width) +
+        FfiConverterUInt32.allocationSize(value.height) +
+        FfiConverterUInt32.allocationSize(value.rotationDegrees) +
+        FfiConverterUInt32.allocationSize(value.frameRate) +
+        FfiConverterOptionalString.allocationSize(value.videoCodec) +
+        FfiConverterOptionalString.allocationSize(value.audioCodec) +
+        FfiConverterOptionalUInt32.allocationSize(value.audioSampleRate) +
+        FfiConverterOptionalUInt32.allocationSize(value.audioChannels) +
+        FfiConverterTypeAuthenticityData.allocationSize(value.authenticityData) +
+        FfiConverterOptionalTypeFilmStyleInfo.allocationSize(value.filmStyle)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+const stringConverter = {
+  stringToBytes: (s: string) =>
+    uniffiCaller.rustCall((status) =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_arraybuffer(s, status),
+    ),
+  bytesToString: (ab: UniffiByteArray) =>
+    uniffiCaller.rustCall((status) =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__arraybuffer_to_string(ab, status),
+    ),
+  stringByteLength: (s: string) =>
+    uniffiCaller.rustCall((status) =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(s, status),
+    ),
+};
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+export enum AuthenticityStatus {
+  Unknown,
+  NoManifest,
+  InvalidManifest,
+  Bindings,
+  Proof,
+}
+
+const FfiConverterTypeAuthenticityStatus = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = AuthenticityStatus;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return AuthenticityStatus.Unknown;
+        case 2:
+          return AuthenticityStatus.NoManifest;
+        case 3:
+          return AuthenticityStatus.InvalidManifest;
+        case 4:
+          return AuthenticityStatus.Bindings;
+        case 5:
+          return AuthenticityStatus.Proof;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case AuthenticityStatus.Unknown:
+          return ordinalConverter.write(1, into);
+        case AuthenticityStatus.NoManifest:
+          return ordinalConverter.write(2, into);
+        case AuthenticityStatus.InvalidManifest:
+          return ordinalConverter.write(3, into);
+        case AuthenticityStatus.Bindings:
+          return ordinalConverter.write(4, into);
+        case AuthenticityStatus.Proof:
+          return ordinalConverter.write(5, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Flat error type: C2paError
+export enum C2paError_Tags {
+  C2pa = "C2pa",
+  Json = "Json",
+  Io = "Io",
+  Base64 = "Base64",
+  NoActiveManifest = "NoActiveManifest",
+  NoHash = "NoHash",
+  FormatNotSupported = "FormatNotSupported",
+  Poisoned = "Poisoned",
+}
+export const C2paError = (() => {
+  class C2pa extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "C2paError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 1;
+
+    public readonly tag = C2paError_Tags.C2pa;
+
+    constructor(message: string) {
+      super("C2paError", "C2pa", message);
+    }
+
+    static instanceOf(e: any): e is C2pa {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 1;
+    }
+  }
+  class Json extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "C2paError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 2;
+
+    public readonly tag = C2paError_Tags.Json;
+
+    constructor(message: string) {
+      super("C2paError", "Json", message);
+    }
+
+    static instanceOf(e: any): e is Json {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 2;
+    }
+  }
+  class Io extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "C2paError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 3;
+
+    public readonly tag = C2paError_Tags.Io;
+
+    constructor(message: string) {
+      super("C2paError", "Io", message);
+    }
+
+    static instanceOf(e: any): e is Io {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 3;
+    }
+  }
+  class Base64 extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "C2paError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 4;
+
+    public readonly tag = C2paError_Tags.Base64;
+
+    constructor(message: string) {
+      super("C2paError", "Base64", message);
+    }
+
+    static instanceOf(e: any): e is Base64 {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 4;
+    }
+  }
+  class NoActiveManifest extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "C2paError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 5;
+
+    public readonly tag = C2paError_Tags.NoActiveManifest;
+
+    constructor(message: string) {
+      super("C2paError", "NoActiveManifest", message);
+    }
+
+    static instanceOf(e: any): e is NoActiveManifest {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 5;
+    }
+  }
+  class NoHash extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "C2paError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 6;
+
+    public readonly tag = C2paError_Tags.NoHash;
+
+    constructor(message: string) {
+      super("C2paError", "NoHash", message);
+    }
+
+    static instanceOf(e: any): e is NoHash {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 6;
+    }
+  }
+  class FormatNotSupported extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "C2paError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 7;
+
+    public readonly tag = C2paError_Tags.FormatNotSupported;
+
+    constructor(message: string) {
+      super("C2paError", "FormatNotSupported", message);
+    }
+
+    static instanceOf(e: any): e is FormatNotSupported {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 7;
+    }
+  }
+  class Poisoned extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [uniffiTypeNameSymbol]: string = "C2paError";
+    /**
+     * @private
+     * This field is private and should not be used.
+     */
+    readonly [variantOrdinalSymbol] = 8;
+
+    public readonly tag = C2paError_Tags.Poisoned;
+
+    constructor(message: string) {
+      super("C2paError", "Poisoned", message);
+    }
+
+    static instanceOf(e: any): e is Poisoned {
+      return instanceOf(e) && (e as any)[variantOrdinalSymbol] === 8;
+    }
+  }
+
+  // Utility function which does not rely on instanceof.
+  function instanceOf(e: any): e is C2paError {
+    return (e as any)[uniffiTypeNameSymbol] === "C2paError";
+  }
+  return {
+    C2pa,
+    Json,
+    Io,
+    Base64,
+    NoActiveManifest,
+    NoHash,
+    FormatNotSupported,
+    Poisoned,
+    instanceOf,
+  };
+})();
+
+// Union type for C2paError error type.
+
+export type C2paError = InstanceType<
+  (typeof C2paError)[keyof Omit<typeof C2paError, "instanceOf">]
+>;
+
+const FfiConverterTypeC2paError = (() => {
+  const intConverter = FfiConverterInt32;
+  type TypeName = C2paError;
+  class FfiConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (intConverter.read(from)) {
+        case 1:
+          return new C2paError.C2pa(FfiConverterString.read(from));
+
+        case 2:
+          return new C2paError.Json(FfiConverterString.read(from));
+
+        case 3:
+          return new C2paError.Io(FfiConverterString.read(from));
+
+        case 4:
+          return new C2paError.Base64(FfiConverterString.read(from));
+
+        case 5:
+          return new C2paError.NoActiveManifest(FfiConverterString.read(from));
+
+        case 6:
+          return new C2paError.NoHash(FfiConverterString.read(from));
+
+        case 7:
+          return new C2paError.FormatNotSupported(FfiConverterString.read(from));
+
+        case 8:
+          return new C2paError.Poisoned(FfiConverterString.read(from));
+
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      const obj = value as any;
+      const index = obj[variantOrdinalSymbol] as number;
+      intConverter.write(index, into);
+    }
+    allocationSize(value: TypeName): number {
+      return intConverter.allocationSize(0);
+    }
+  }
+  return new FfiConverter();
+})();
+
+export interface ManifestInterface {
+  bindings(): DeviceBindings | undefined;
+  captureMetadataAction() /*throws*/ : string | undefined;
+  proof(): Proof | undefined;
+}
+
+export class Manifest extends UniffiAbstractObject implements ManifestInterface {
+  readonly [uniffiTypeNameSymbol] = "Manifest";
+  readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+  readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+  // No primary constructor declared for this class.
+  private constructor(pointer: UnsafeMutableRawPointer) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeManifestObjectFactory.bless(pointer);
+  }
+
+  public bindings(): DeviceBindings | undefined {
+    return FfiConverterOptionalTypeDeviceBindings.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifest_bindings(
+            uniffiTypeManifestObjectFactory.clonePointer(this),
+            callStatus,
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift,
+      ),
+    );
+  }
+
+  public captureMetadataAction(): string | undefined /*throws*/ {
+    return FfiConverterOptionalString.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifest_capture_metadata_action(
+            uniffiTypeManifestObjectFactory.clonePointer(this),
+            callStatus,
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift,
+      ),
+    );
+  }
+
+  public proof(): Proof | undefined {
+    return FfiConverterOptionalTypeProof.lift(
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifest_proof(
+            uniffiTypeManifestObjectFactory.clonePointer(this),
+            callStatus,
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift,
+      ),
+    );
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeManifestObjectFactory.pointer(this);
+      uniffiTypeManifestObjectFactory.freePointer(pointer);
+      uniffiTypeManifestObjectFactory.unbless(ptr);
+      delete (this as any)[destructorGuardSymbol];
+    }
+  }
+
+  static instanceOf(obj: any): obj is Manifest {
+    return uniffiTypeManifestObjectFactory.isConcreteType(obj);
+  }
+}
+
+const uniffiTypeManifestObjectFactory: UniffiObjectFactory<ManifestInterface> = (() => {
+  return {
+    create(pointer: UnsafeMutableRawPointer): ManifestInterface {
+      const instance = Object.create(Manifest.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "Manifest";
+      return instance;
+    },
+
+    bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr {
+      return uniffiCaller.rustCall(
+        /*caller:*/ (status) =>
+          nativeModule().ubrn_uniffi_internal_fn_method_manifest_ffi__bless_pointer(p, status),
+        /*liftString:*/ FfiConverterString.lift,
+      );
+    },
+
+    unbless(ptr: UniffiRustArcPtr) {
+      ptr.markDestroyed();
+    },
+
+    pointer(obj: ManifestInterface): UnsafeMutableRawPointer {
+      if ((obj as any)[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer();
+      }
+      return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: ManifestInterface): UnsafeMutableRawPointer {
+      const pointer = this.pointer(obj);
+      return uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) =>
+          nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_clone_manifest(pointer, callStatus),
+        /*liftString:*/ FfiConverterString.lift,
+      );
+    },
+
+    freePointer(pointer: UnsafeMutableRawPointer): void {
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) =>
+          nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_free_manifest(pointer, callStatus),
+        /*liftString:*/ FfiConverterString.lift,
+      );
+    },
+
+    isConcreteType(obj: any): obj is ManifestInterface {
+      return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "Manifest";
+    },
+  };
+})();
+// FfiConverter for ManifestInterface
+const FfiConverterTypeManifest = new FfiConverterObject(uniffiTypeManifestObjectFactory);
+
+export interface ManifestEditorInterface {
+  addAssertion(label: string, data: string) /*throws*/ : void;
+  addPhotoMetadataAction(parameters: PhotoMetadataInfo, when: string) /*throws*/ : string;
+  addTitle(title: string) /*throws*/ : void;
+  addVideoMetadataAction(parameters: VideoMetadataInfo, when: string) /*throws*/ : string;
+  embedManifestToFile(
+    destination: string,
+    format: string,
+    asyncOpts_?: { signal: AbortSignal },
+  ) /*throws*/ : Promise<void>;
+  removeAssertion(label: string) /*throws*/ : boolean;
+}
+
+export class ManifestEditor extends UniffiAbstractObject implements ManifestEditorInterface {
+  readonly [uniffiTypeNameSymbol] = "ManifestEditor";
+  readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+  readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+  constructor(path: string, keyTag: ArrayBuffer, certs: string) {
+    super();
+    const pointer = uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_constructor_manifesteditor_new(
+          FfiConverterString.lower(path),
+          FfiConverterArrayBuffer.lower(keyTag),
+          FfiConverterString.lower(certs),
+          callStatus,
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    );
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeManifestEditorObjectFactory.bless(pointer);
+  }
+
+  /**
+   * Creates a builder from a file that is expected to contain an existing C2PA manifest.
+   *
+   * The metadata included in the manifest are kept.
+   */
+  public static fromManifest(
+    path: string,
+    keyTag: ArrayBuffer,
+    certs: string,
+  ): ManifestEditorInterface /*throws*/ {
+    return FfiConverterTypeManifestEditor.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_constructor_manifesteditor_from_manifest(
+            FfiConverterString.lower(path),
+            FfiConverterArrayBuffer.lower(keyTag),
+            FfiConverterString.lower(certs),
+            callStatus,
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift,
+      ),
+    );
+  }
+
+  public addAssertion(label: string, data: string): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_add_assertion(
+          uniffiTypeManifestEditorObjectFactory.clonePointer(this),
+          FfiConverterString.lower(label),
+          FfiConverterString.lower(data),
+          callStatus,
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    );
+  }
+
+  public addPhotoMetadataAction(parameters: PhotoMetadataInfo, when: string): string /*throws*/ {
+    return FfiConverterString.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_add_photo_metadata_action(
+            uniffiTypeManifestEditorObjectFactory.clonePointer(this),
+            FfiConverterTypePhotoMetadataInfo.lower(parameters),
+            FfiConverterString.lower(when),
+            callStatus,
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift,
+      ),
+    );
+  }
+
+  public addTitle(title: string): void /*throws*/ {
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_add_title(
+          uniffiTypeManifestEditorObjectFactory.clonePointer(this),
+          FfiConverterString.lower(title),
+          callStatus,
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift,
+    );
+  }
+
+  public addVideoMetadataAction(parameters: VideoMetadataInfo, when: string): string /*throws*/ {
+    return FfiConverterString.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_add_video_metadata_action(
+            uniffiTypeManifestEditorObjectFactory.clonePointer(this),
+            FfiConverterTypeVideoMetadataInfo.lower(parameters),
+            FfiConverterString.lower(when),
+            callStatus,
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift,
+      ),
+    );
+  }
+
+  public async embedManifestToFile(
+    destination: string,
+    format: string,
+    asyncOpts_?: { signal: AbortSignal },
+  ): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_embed_manifest_to_file(
+            uniffiTypeManifestEditorObjectFactory.clonePointer(this),
+            FfiConverterString.lower(destination),
+            FfiConverterString.lower(format),
+          );
+        },
+        /*pollFunc:*/ nativeModule().ubrn_ffi_zcam1_c2pa_utils_rust_future_poll_void,
+        /*cancelFunc:*/ nativeModule().ubrn_ffi_zcam1_c2pa_utils_rust_future_cancel_void,
+        /*completeFunc:*/ nativeModule().ubrn_ffi_zcam1_c2pa_utils_rust_future_complete_void,
+        /*freeFunc:*/ nativeModule().ubrn_ffi_zcam1_c2pa_utils_rust_future_free_void,
+        /*liftFunc:*/ (_v) => {},
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
+  public removeAssertion(label: string): boolean /*throws*/ {
+    return FfiConverterBool.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifesteditor_remove_assertion(
+            uniffiTypeManifestEditorObjectFactory.clonePointer(this),
+            FfiConverterString.lower(label),
+            callStatus,
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift,
+      ),
+    );
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeManifestEditorObjectFactory.pointer(this);
+      uniffiTypeManifestEditorObjectFactory.freePointer(pointer);
+      uniffiTypeManifestEditorObjectFactory.unbless(ptr);
+      delete (this as any)[destructorGuardSymbol];
+    }
+  }
+
+  static instanceOf(obj: any): obj is ManifestEditor {
+    return uniffiTypeManifestEditorObjectFactory.isConcreteType(obj);
+  }
+}
+
+const uniffiTypeManifestEditorObjectFactory: UniffiObjectFactory<ManifestEditorInterface> = (() => {
+  return {
+    create(pointer: UnsafeMutableRawPointer): ManifestEditorInterface {
+      const instance = Object.create(ManifestEditor.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "ManifestEditor";
+      return instance;
+    },
+
+    bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr {
+      return uniffiCaller.rustCall(
+        /*caller:*/ (status) =>
+          nativeModule().ubrn_uniffi_internal_fn_method_manifesteditor_ffi__bless_pointer(
+            p,
+            status,
+          ),
+        /*liftString:*/ FfiConverterString.lift,
+      );
+    },
+
+    unbless(ptr: UniffiRustArcPtr) {
+      ptr.markDestroyed();
+    },
+
+    pointer(obj: ManifestEditorInterface): UnsafeMutableRawPointer {
+      if ((obj as any)[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer();
+      }
+      return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: ManifestEditorInterface): UnsafeMutableRawPointer {
+      const pointer = this.pointer(obj);
+      return uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) =>
+          nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_clone_manifesteditor(pointer, callStatus),
+        /*liftString:*/ FfiConverterString.lift,
+      );
+    },
+
+    freePointer(pointer: UnsafeMutableRawPointer): void {
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) =>
+          nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_free_manifesteditor(pointer, callStatus),
+        /*liftString:*/ FfiConverterString.lift,
+      );
+    },
+
+    isConcreteType(obj: any): obj is ManifestEditorInterface {
+      return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "ManifestEditor";
+    },
+  };
+})();
+// FfiConverter for ManifestEditorInterface
+const FfiConverterTypeManifestEditor = new FfiConverterObject(
+  uniffiTypeManifestEditorObjectFactory,
+);
+
+export interface ManifestStoreInterface {
+  activeManifest() /*throws*/ : ManifestInterface;
+}
+
+export class ManifestStore extends UniffiAbstractObject implements ManifestStoreInterface {
+  readonly [uniffiTypeNameSymbol] = "ManifestStore";
+  readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+  readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+  // No primary constructor declared for this class.
+  private constructor(pointer: UnsafeMutableRawPointer) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeManifestStoreObjectFactory.bless(pointer);
+  }
+
+  public activeManifest(): ManifestInterface /*throws*/ {
+    return FfiConverterTypeManifest.lift(
+      uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeC2paError.lift.bind(FfiConverterTypeC2paError),
+        /*caller:*/ (callStatus) => {
+          return nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_method_manifeststore_active_manifest(
+            uniffiTypeManifestStoreObjectFactory.clonePointer(this),
+            callStatus,
+          );
+        },
+        /*liftString:*/ FfiConverterString.lift,
+      ),
+    );
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeManifestStoreObjectFactory.pointer(this);
+      uniffiTypeManifestStoreObjectFactory.freePointer(pointer);
+      uniffiTypeManifestStoreObjectFactory.unbless(ptr);
+      delete (this as any)[destructorGuardSymbol];
+    }
+  }
+
+  static instanceOf(obj: any): obj is ManifestStore {
+    return uniffiTypeManifestStoreObjectFactory.isConcreteType(obj);
+  }
+}
+
+const uniffiTypeManifestStoreObjectFactory: UniffiObjectFactory<ManifestStoreInterface> = (() => {
+  return {
+    create(pointer: UnsafeMutableRawPointer): ManifestStoreInterface {
+      const instance = Object.create(ManifestStore.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "ManifestStore";
+      return instance;
+    },
+
+    bless(p: UnsafeMutableRawPointer): UniffiRustArcPtr {
+      return uniffiCaller.rustCall(
+        /*caller:*/ (status) =>
+          nativeModule().ubrn_uniffi_internal_fn_method_manifeststore_ffi__bless_pointer(p, status),
+        /*liftString:*/ FfiConverterString.lift,
+      );
+    },
+
+    unbless(ptr: UniffiRustArcPtr) {
+      ptr.markDestroyed();
+    },
+
+    pointer(obj: ManifestStoreInterface): UnsafeMutableRawPointer {
+      if ((obj as any)[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer();
+      }
+      return (obj as any)[pointerLiteralSymbol];
+    },
+
+    clonePointer(obj: ManifestStoreInterface): UnsafeMutableRawPointer {
+      const pointer = this.pointer(obj);
+      return uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) =>
+          nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_clone_manifeststore(pointer, callStatus),
+        /*liftString:*/ FfiConverterString.lift,
+      );
+    },
+
+    freePointer(pointer: UnsafeMutableRawPointer): void {
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) =>
+          nativeModule().ubrn_uniffi_zcam1_c2pa_utils_fn_free_manifeststore(pointer, callStatus),
+        /*liftString:*/ FfiConverterString.lift,
+      );
+    },
+
+    isConcreteType(obj: any): obj is ManifestStoreInterface {
+      return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "ManifestStore";
+    },
+  };
+})();
+// FfiConverter for ManifestStoreInterface
+const FfiConverterTypeManifestStore = new FfiConverterObject(uniffiTypeManifestStoreObjectFactory);
+
+// FfiConverter for DepthData | undefined
+const FfiConverterOptionalTypeDepthData = new FfiConverterOptional(FfiConverterTypeDepthData);
+
+// FfiConverter for DeviceBindings | undefined
+const FfiConverterOptionalTypeDeviceBindings = new FfiConverterOptional(
+  FfiConverterTypeDeviceBindings,
+);
+
+// FfiConverter for FilmStyleInfo | undefined
+const FfiConverterOptionalTypeFilmStyleInfo = new FfiConverterOptional(
+  FfiConverterTypeFilmStyleInfo,
+);
+
+// FfiConverter for Proof | undefined
+const FfiConverterOptionalTypeProof = new FfiConverterOptional(FfiConverterTypeProof);
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+// FfiConverter for /*u32*/number | undefined
+const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
+
+/**
+ * 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 = 29;
+  // Get the scaffolding contract version by calling the into the dylib
+  const scaffoldingContractVersion =
+    nativeModule().ubrn_ffi_zcam1_c2pa_utils_uniffi_contract_version();
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(
+      scaffoldingContractVersion,
+      bindingsContractVersion,
+    );
+  }
+  if (nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_func_authenticity_status() !== 16408) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_func_authenticity_status",
+    );
+  }
+  if (nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_func_compute_hash() !== 19539) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_func_compute_hash",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_func_compute_hash_from_buffer() !== 10723
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_func_compute_hash_from_buffer",
+    );
+  }
+  if (nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_func_extract_manifest() !== 13636) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_func_extract_manifest",
+    );
+  }
+  if (nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_func_format_from_path() !== 30877) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_func_format_from_path",
+    );
+  }
+  if (nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifest_bindings() !== 48636) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_method_manifest_bindings",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifest_capture_metadata_action() !==
+    58322
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_method_manifest_capture_metadata_action",
+    );
+  }
+  if (nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifest_proof() !== 61561) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_method_manifest_proof",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_assertion() !==
+    1861
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_assertion",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_photo_metadata_action() !==
+    29229
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_photo_metadata_action",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_title() !== 41603
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_title",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_video_metadata_action() !==
+    1551
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_add_video_metadata_action",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_embed_manifest_to_file() !==
+    51702
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_embed_manifest_to_file",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_remove_assertion() !==
+    9530
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_method_manifesteditor_remove_assertion",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_method_manifeststore_active_manifest() !==
+    39667
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_method_manifeststore_active_manifest",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_constructor_manifesteditor_from_manifest() !==
+    16267
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_constructor_manifesteditor_from_manifest",
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_zcam1_c2pa_utils_checksum_constructor_manifesteditor_new() !== 9414
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_zcam1_c2pa_utils_checksum_constructor_manifesteditor_new",
+    );
+  }
+}
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeAuthenticityData,
+    FfiConverterTypeAuthenticityStatus,
+    FfiConverterTypeC2paError,
+    FfiConverterTypeClaim,
+    FfiConverterTypeDepthData,
+    FfiConverterTypeDepthDataStatistics,
+    FfiConverterTypeDeviceBindings,
+    FfiConverterTypeExclusion,
+    FfiConverterTypeFilmStyleInfo,
+    FfiConverterTypeManifest,
+    FfiConverterTypeManifestEditor,
+    FfiConverterTypeManifestStore,
+    FfiConverterTypePhotoMetadataInfo,
+    FfiConverterTypeProof,
+    FfiConverterTypeVideoMetadataInfo,
+  },
+});