@trylimbo/sdk-verifier 0.1.0-canary.100

package/gen/ffi/index.d.ts

@@ -0,0 +1,4026 @@
+//#region ../../../../node_modules/@ubjs/core/dist/esm/ffi-types.d.ts
+type UniffiByteArray = Uint8Array;
+//#endregion
+//#region ../../../../node_modules/@ubjs/core/dist/esm/cursor.d.ts
+/**
+ * Positional reader/writer over an `ArrayBuffer` slice with monomorphic typed
+ * accessors. One `DataView` and one `Uint8Array` are built at construction and
+ * reused for every primitive operation — no per-read DataView allocation, no
+ * function-pointer dispatch.
+ *
+ * Big-endian on the wire (matches the UniFFI RustBuffer wire format).
+ */
+declare class Cursor {
+  private readonly dv;
+  private readonly u8;
+  private readonly start;
+  private readonly end;
+  private pos;
+  constructor(buffer: ArrayBuffer, offset: number, length: number);
+  static fromUint8Array(view: Uint8Array): Cursor;
+  remaining(): number;
+  skip(n: number): void;
+  readU8(): number;
+  readI8(): number;
+  readU16(): number;
+  readI16(): number;
+  readU32(): number;
+  readI32(): number;
+  readU64(): bigint;
+  readI64(): bigint;
+  readF32(): number;
+  readF64(): number;
+  readBool(): boolean;
+  writeU8(v: number): void;
+  writeI8(v: number): void;
+  writeU16(v: number): void;
+  writeI16(v: number): void;
+  writeU32(v: number): void;
+  writeI32(v: number): void;
+  writeU64(v: bigint): void;
+  writeI64(v: bigint): void;
+  writeF32(v: number): void;
+  writeF64(v: number): void;
+  writeBool(v: boolean): void;
+  readBytes(len: number): Uint8Array;
+  readArrayBuffer(len: number): ArrayBuffer;
+  writeBytes(src: Uint8Array): void;
+  private boundsCheck;
+}
+//#endregion
+//#region ../../../../node_modules/@ubjs/core/dist/esm/ffi-converters.d.ts
+type RustBufferAllocator = (n: number) => Uint8Array;
+interface FfiConverter<FfiType, TsType> {
+  lift(value: FfiType): TsType;
+  lower(value: TsType, alloc: RustBufferAllocator): FfiType;
+  readFromCursor(c: Cursor): TsType;
+  writeIntoCursor(value: TsType, c: Cursor): void;
+  allocationSize(value: TsType): number;
+}
+//#endregion
+//#region ../../../../node_modules/@ubjs/core/dist/esm/handle-map.d.ts
+type UniffiHandle = bigint;
+declare class UniffiHandleMap<T> {
+  private map;
+  private currentHandle;
+  insert(value: T): UniffiHandle;
+  get(handle: UniffiHandle): T;
+  /**
+   * Creates a second handle pointing to the same object. Rust calls this (via
+   * `CallbackInterfaceClone`) when it clones an Arc holding a foreign-implemented
+   * trait object, so two Arc references can exist with independent lifetimes.
+   *
+   * This clones the *handle*, not the object itself. Both handles resolve to the
+   * same JS object reference, and removing either handle does not affect the other.
+   */
+  clone(handle: UniffiHandle): UniffiHandle;
+  remove(handle: UniffiHandle): T | undefined;
+  has(handle: UniffiHandle): boolean;
+  get size(): number;
+}
+//#endregion
+//#region ../../../../node_modules/@ubjs/core/dist/esm/rust-call.d.ts
+/**
+ * A member of any object, acting as a GC guard / destructor guard.
+ *
+ * The object has a destructor lambda, called when the GC collects the object.
+ */
+type UniffiGcObject = {
+  /**
+   * Called by the `object.uniffiDestroy()` to disable the
+   * action of the destructor guard.
+   */
+  markDestroyed(): void;
+};
+//#endregion
+//#region ../../../../node_modules/@ubjs/core/dist/esm/objects.d.ts
+/**
+ * Marker interface for all `interface` objects that cross the FFI.
+ * Reminder: `interface` objects have methods written in Rust.
+ *
+ * This typesscript interface contains the unffi methods that are needed to make
+ * the FFI work. It should shrink to zero methods.
+ */
+declare abstract class UniffiAbstractObject {
+  /**
+   * Explicitly tell Rust to destroy the native peer that backs this object.
+   *
+   * Once this method has been called, any following method calls will throw an error.
+   *
+   * Can be called more than once.
+   */
+  abstract uniffiDestroy(): void;
+  /**
+   * A convenience method to use this object, then destroy it after its use.
+   * @param block
+   * @returns
+   */
+  uniffiUse<T>(block: (obj: this) => T): T;
+}
+/**
+ * The interface for a helper class generated for each `interface` class.
+ *
+ * Methods of this interface are not exposed to the API.
+ */
+interface UniffiObjectFactory<T> {
+  bless(pointer: UniffiHandle): UniffiGcObject;
+  unbless(ptr: UniffiGcObject): void;
+  create(pointer: UniffiHandle): T;
+  pointer(obj: T): UniffiHandle;
+  clonePointer(obj: T): UniffiHandle;
+  freePointer(pointer: UniffiHandle): void;
+  isConcreteType(obj: any): obj is T;
+}
+/**
+ * An FfiConverter for an object.
+ */
+declare class FfiConverterObject<T> implements FfiConverter<UniffiHandle, T> {
+  protected factory: UniffiObjectFactory<T>;
+  constructor(factory: UniffiObjectFactory<T>);
+  lift(value: UniffiHandle): T;
+  lower(value: T, _alloc: RustBufferAllocator): UniffiHandle;
+  readFromCursor(c: Cursor): T;
+  writeIntoCursor(value: T, c: Cursor): void;
+  protected lowerHandle(value: T): UniffiHandle;
+  allocationSize(value: T): number;
+}
+declare class FfiConverterObjectWithCallbacks<T> extends FfiConverterObject<T> {
+  private handleMap;
+  constructor(factory: UniffiObjectFactory<T>, handleMap?: UniffiHandleMap<T>);
+  protected lowerHandle(value: T): UniffiHandle;
+  lift(value: UniffiHandle): T;
+  drop(handle: UniffiHandle): T | undefined;
+  /**
+   * Called by Rust's `CallbackInterfaceClone` vtable entry when it clones an
+   * Arc holding a foreign-implemented object. Returns a new handle pointing to
+   * the same JS object; removing either handle does not affect the other.
+   */
+  clone(handle: UniffiHandle): UniffiHandle;
+}
+//#endregion
+//#region ../../../../node_modules/@ubjs/core/dist/esm/symbols.d.ts
+/**
+ * A destructor guard object is created for every
+ * `interface` object.
+ *
+ * It corresponds to the `DestructibleObject` in C++, which
+ * uses a C++ destructor to simulate the JS garbage collector.
+ *
+ * The implementation is in {@link RustArcPtr.h}.
+ */
+declare const destructorGuardSymbol: unique symbol;
+/**
+ * The `bigint` pointer corresponding to the Rust memory address
+ * of the native peer.
+ */
+declare const pointerLiteralSymbol: unique symbol;
+/**
+ * The `string` name of the object, enum or error class.
+ *
+ * This drives the `instanceOf` method implementations.
+ */
+declare const uniffiTypeNameSymbol: unique symbol;
+declare namespace trylimbo_verifier_d_exports {
+  export { Actor, AssertionMetadata, AssetType, AssetVerification, AssetVerifier, AssetVerifierInterface, AssetVerifierLike, AssetVerifierOptions, Binder, BinderInterface, BinderLike, ClaimGeneratorInfo, Code, ContentBindingClass, ContentBindingEvidence, Coordinate, CredentialOrigin, CredentialOrigin_Tags, DataSource, DeriveOptions, EndInclusivity, FieldViolation, FileSource, FileSourceInterface, FileSourceLike, FingerprintCheck, FingerprintCheck_Tags, FoundCredential, Frame, GoldenComparison, GoldenComparison_Tags, HashedUri, Ingredient, IngredientDeltaValidationResult, InitValidation, Item, Manifest, ManifestAssertion, ManifestAssertionKind, ManifestStore, MediaValidation, MemorySource, MemorySourceInterface, MemorySourceLike, PluginRead, PluginRegistry, PluginRegistryInterface, PluginRegistryLike, Range, RangeSource, RangeSourceImpl, RangeType, RecoveryIssue, RecoveryIssueKind, RecoveryPolicy, RecoveryStatus, RecoverySummary, Region, RegionOfInterest, RegistryOptions, RegistryQueries, Relationship, ResourceRef, ReviewRating, Role, SdkError, SdkError_Tags, SegmentTiming, SegmentValidation, SegmentValidation_Tags, SessionKeySummary, Shape, ShapeType, SignatureInfo, SigningAlgSchema, SimilarityScore, SoftBinding, StatusCodes, StreamValidation, StreamValidationInterface, StreamValidationLike, StreamVerifier, StreamVerifierInterface, StreamVerifierLike, StreamVerifierOptions, Text, TextSelector, TextSelectorRange, Time, TimeType, UnitType, UriOrResource, UriOrResource_Tags, ValidationCode, ValidationCodeKind, ValidationResults, ValidationState, ValidationStatus, Value, VerifyOptions, c2paTrustList, c2paTsaTrustList, _default$1 as default, devCa, parse, resource, thumbnails };
+}
+/**
+ * Official C2PA Conformance Program signing-CA trust anchors (a compile-time
+ * snapshot). Trusted by default already; exposed for callers pinning their own list.
+ */
+declare function c2paTrustList(): string;
+/**
+ * Official C2PA time-stamping-authority (TSA) trust anchors (a compile-time snapshot).
+ */
+declare function c2paTsaTrustList(): string;
+/**
+ * PEM trust anchor for the Limbo Integrity development signing environment, **development
+ * only**, no security guarantees. Never ship it in a release anchor list.
+ */
+declare function devCa(): string;
+/**
+ * Parse a detached C2PA manifest store: a `.c2pa` sidecar, or the bytes a registry serves for a
+ * manifest id.
+ *
+ * Contents, not a verdict. A hard binding is a hash of the asset, so a store read without one
+ * says nothing about whether the credential is authentic or which file it belongs to, and the
+ * validation fields it carries are not a state anything established here; verifying is
+ * `AssetVerifier.verify`, which takes the asset.
+ *
+ * Runs on the calling thread rather than an SDK worker, unlike `embed`: a manifest store is
+ * bounded by the decompression ceiling, where an asset is not.
+ *
+ * # Errors
+ *
+ * `READER_INVALID` when the bytes are not a manifest store c2pa can parse.
+ */
+declare function parse(manifest: ArrayBuffer): ManifestStore;
+/**
+ * The bytes of one resource in a detached manifest store, or nothing when it holds none under
+ * `uri`.
+ *
+ * `uri` is the `identifier` on a resource reference the store carries, so walking the chain in
+ * the parsed store is what produces it: any manifest's claim thumbnail, including a non-active
+ * one, and any ingredient's. Render it with the `format` beside that identifier. A `uri` naming a
+ * manifest rather than a resource answers that manifest's own JUMBF, so pass what a reference
+ * states, never a bare label.
+ *
+ * # Errors
+ *
+ * `READER_INVALID` when the bytes are not a manifest store c2pa can parse, or the store holds
+ * the resource but cannot produce it.
+ */
+declare function resource(manifest: ArrayBuffer, uri: string): ArrayBuffer | undefined;
+/**
+ * Every thumbnail the store references, by the `identifier` it references them under: each
+ * manifest's claim thumbnail and each ingredient's.
+ *
+ * One parse for the whole set, where [`resource`] pays one per call. A reference the store cannot
+ * produce is left out rather than failing the set.
+ *
+ * # Errors
+ *
+ * `READER_INVALID` when the bytes are not a manifest store c2pa can parse.
+ */
+declare function thumbnails(manifest: ArrayBuffer): Map<string, ArrayBuffer>;
+/**
+ * A `HashedUri` provides a reference to content available within the same
+ * manifest store.
+ *
+ * This is described in [URI References in the C2PA Technical
+ * Specification](https://spec.c2pa.org/specifications/specifications/2.3/specs/C2PA_Specification.html#_uri_references).
+ */
+type HashedUri = {
+  /**
+   * A string identifying the cryptographic hash algorithm used to compute
+   * the hash
+   */
+  alg?: string;
+  /**
+   * Byte string containing the hash value
+   */
+  hash: ArrayBuffer;
+  /**
+   * JUMBF URI reference
+   */
+  url: string;
+};
+/**
+ * Generated factory for {@link HashedUri} record objects.
+ */
+declare const HashedUri: Readonly<{
+  create: (partial: Partial<HashedUri> & Required<Omit<HashedUri, "alg">>) => HashedUri;
+  new: (partial: Partial<HashedUri> & Required<Omit<HashedUri, "alg">>) => HashedUri;
+  defaults: () => Partial<HashedUri>;
+}>;
+/**
+ * Identifies a person responsible for an action.
+ */
+type Actor = {
+  /**
+   * List of references to W3C Verifiable Credentials.
+   */
+  credentials?: Array<HashedUri>;
+  /**
+   * An identifier for a human actor, used when the "type" is `humanEntry.identified`.
+   */
+  identifier?: string;
+};
+/**
+ * Generated factory for {@link Actor} record objects.
+ */
+declare const Actor: Readonly<{
+  create: (partial: Partial<Actor> & Required<Omit<Actor, "credentials" | "identifier">>) => Actor;
+  new: (partial: Partial<Actor> & Required<Omit<Actor, "credentials" | "identifier">>) => Actor;
+  defaults: () => Partial<Actor>;
+}>;
+/**
+ * A description of the source for assertion data
+ */
+type DataSource = {
+  /**
+   * A list of [`Actor`]s associated with this source.
+   */
+  actors?: Array<Actor>;
+  /**
+   * A human-readable string giving details about the source of the assertion data.
+   */
+  details?: string;
+  /**
+   * A value from among the enumerated list indicating the source of the assertion.
+   */
+  type: string;
+};
+/**
+ * Generated factory for {@link DataSource} record objects.
+ */
+declare const DataSource: Readonly<{
+  create: (partial: Partial<DataSource> & Required<Omit<DataSource, "actors" | "details">>) => DataSource;
+  new: (partial: Partial<DataSource> & Required<Omit<DataSource, "actors" | "details">>) => DataSource;
+  defaults: () => Partial<DataSource>;
+}>;
+/**
+ * Typealias from the type name used in the UDL file to the builtin type.  This
+ * is needed because the UDL type name is used in function/method signatures.
+ */
+type Value = string;
+/**
+ * A frame range representing starting and ending frames or pages.
+ *
+ * If both `start` and `end` are missing, the frame will span the entire asset.
+ */
+type Frame = {
+  /**
+   * The end of the frame inclusive or the end of the asset if not present.
+   */
+  end?: number;
+  /**
+   * The start of the frame or the end of the asset if not present.
+   *
+   * The first frame/page starts at 0.
+   */
+  start?: number;
+};
+/**
+ * Generated factory for {@link Frame} record objects.
+ */
+declare const Frame: Readonly<{
+  create: (partial: Partial<Frame> & Required<Omit<Frame, "end" | "start">>) => Frame;
+  new: (partial: Partial<Frame> & Required<Omit<Frame, "end" | "start">>) => Frame;
+  defaults: () => Partial<Frame>;
+}>;
+/**
+ * Description of the boundaries of an identified range.
+ */
+type Item = {
+  /**
+   * The container-specific term used to identify items, such as "track_id" for MP4 or "item_ID" for HEIF.
+   */
+  identifier: string;
+  /**
+   * The value of the identifier, e.g. a value of "2" for an identifier of "track_id" would imply track 2 of the asset.
+   */
+  value: string;
+};
+/**
+ * Generated factory for {@link Item} record objects.
+ */
+declare const Item: Readonly<{
+  create: (partial: Partial<Item> & Required<Omit<Item, never>>) => Item;
+  new: (partial: Partial<Item> & Required<Omit<Item, never>>) => Item;
+  defaults: () => Partial<Item>;
+}>;
+/**
+ * An x, y coordinate used for specifying vertices in polygons.
+ */
+type Coordinate = {
+  /**
+   * The coordinate along the x-axis.
+   */
+  x: number;
+  /**
+   * The coordinate along the y-axis.
+   */
+  y: number;
+};
+/**
+ * Generated factory for {@link Coordinate} record objects.
+ */
+declare const Coordinate: Readonly<{
+  create: (partial: Partial<Coordinate> & Required<Omit<Coordinate, never>>) => Coordinate;
+  new: (partial: Partial<Coordinate> & Required<Omit<Coordinate, never>>) => Coordinate;
+  defaults: () => Partial<Coordinate>;
+}>;
+/**
+ * The type of shape for the range.
+ */
+declare enum ShapeType {
+  /**
+   * A rectangle.
+   */
+  Rectangle = 0,
+  /**
+   * A circle.
+   */
+  Circle = 1,
+  /**
+   * A polygon.
+   */
+  Polygon = 2
+}
+/**
+ * The type of unit for the range.
+ */
+declare enum UnitType {
+  /**
+   * Use pixels.
+   */
+  Pixel = 0,
+  /**
+   * Use percentage.
+   */
+  Percent = 1
+}
+/**
+ * A spatial range representing rectangle, circle, or a polygon.
+ */
+type Shape = {
+  /**
+   * The height of a rectnagle.
+   *
+   * This field can be ignored for circles and polygons.
+   */
+  height?: number;
+  /**
+   * If the range is inside the shape.
+   *
+   * The default value is true.
+   */
+  inside?: boolean;
+  /**
+   * THe origin of the coordinate in the shape.
+   */
+  origin: Coordinate;
+  /**
+   * The type of shape.
+   */
+  type: ShapeType;
+  /**
+   * The type of unit for the shape range.
+   */
+  unit: UnitType;
+  /**
+   * The vertices of the polygon.
+   *
+   * This field can be ignored for rectangles and circles.
+   */
+  vertices?: Array<Coordinate>;
+  /**
+   * The width for rectangles or diameter for circles.
+   *
+   * This field can be ignored for polygons.
+   */
+  width?: number;
+};
+/**
+ * Generated factory for {@link Shape} record objects.
+ */
+declare const Shape: Readonly<{
+  create: (partial: Partial<Shape> & Required<Omit<Shape, "height" | "inside" | "vertices" | "width">>) => Shape;
+  new: (partial: Partial<Shape> & Required<Omit<Shape, "height" | "inside" | "vertices" | "width">>) => Shape;
+  defaults: () => Partial<Shape>;
+}>;
+/**
+ * Selects a range of text via a fragment identifier.
+ *
+ * This is modeled after the W3C Web Annotation selector model.
+ */
+type TextSelector = {
+  /**
+   * The end character offset or the end of the fragment if not present.
+   */
+  end?: number;
+  /**
+   * Fragment identifier as per RFC3023 (XML) or ISO 32000-2 (PDF), Annex O.
+   */
+  fragment: string;
+  /**
+   * The start character offset or the start of the fragment if not present.
+   */
+  start?: number;
+};
+/**
+ * Generated factory for {@link TextSelector} record objects.
+ */
+declare const TextSelector: Readonly<{
+  create: (partial: Partial<TextSelector> & Required<Omit<TextSelector, "end" | "start">>) => TextSelector;
+  new: (partial: Partial<TextSelector> & Required<Omit<TextSelector, "end" | "start">>) => TextSelector;
+  defaults: () => Partial<TextSelector>;
+}>;
+/**
+ * One or two [`TextSelector`] identifiying the range to select.
+ */
+type TextSelectorRange = {
+  /**
+   * The end of the text range.
+   */
+  end?: TextSelector;
+  /**
+   * The start (or entire) text range.
+   */
+  selector: TextSelector;
+};
+/**
+ * Generated factory for {@link TextSelectorRange} record objects.
+ */
+declare const TextSelectorRange: Readonly<{
+  create: (partial: Partial<TextSelectorRange> & Required<Omit<TextSelectorRange, "end">>) => TextSelectorRange;
+  new: (partial: Partial<TextSelectorRange> & Required<Omit<TextSelectorRange, "end">>) => TextSelectorRange;
+  defaults: () => Partial<TextSelectorRange>;
+}>;
+/**
+ * A textual range representing multiple (possibly discontinuous) ranges of text.
+ */
+type Text = {
+  /**
+   * The ranges of text to select.
+   */
+  selectors: Array<TextSelectorRange>;
+};
+/**
+ * Generated factory for {@link Text} record objects.
+ */
+declare const Text: Readonly<{
+  create: (partial: Partial<Text> & Required<Omit<Text, never>>) => Text;
+  new: (partial: Partial<Text> & Required<Omit<Text, never>>) => Text;
+  defaults: () => Partial<Text>;
+}>;
+/**
+ * Whether a temporal range includes its ending instant.
+ */
+declare enum EndInclusivity {
+  /**
+   * The ending instant is part of the range.
+   */
+  Inclusive = 0,
+  /**
+   * The ending instant is excluded. This is the Core default.
+   */
+  Exclusive = 1
+}
+/**
+ * The type of time.
+ */
+declare enum TimeType {
+  /**
+   * Times are described using Normal Play Time (npt) as described in RFC 2326.
+   */
+  Npt = 0,
+  /**
+   * Times are absolute RFC 3339 wall-clock instants.
+   */
+  WallClock = 1
+}
+/**
+ * A temporal range representing a starting time to an ending time.
+ */
+type Time = {
+  /**
+   * The end time or the end of the asset if not present.
+   */
+  end?: string;
+  /**
+   * Whether the ending instant is inclusive. Omission means `exclusive`.
+   */
+  endInclusivity?: EndInclusivity;
+  /**
+   * The start time or the start of the asset if not present.
+   */
+  start?: string;
+  /**
+   * The type of time.
+   */
+  type: TimeType;
+};
+/**
+ * Generated factory for {@link Time} record objects.
+ */
+declare const Time: Readonly<{
+  create: (partial: Partial<Time> & Required<Omit<Time, "end" | "endInclusivity" | "start">>) => Time;
+  new: (partial: Partial<Time> & Required<Omit<Time, "end" | "endInclusivity" | "start">>) => Time;
+  defaults: () => Partial<Time>;
+}>;
+/**
+ * The type of range for the region of interest.
+ */
+declare enum RangeType {
+  /**
+   * A spatial range, see [`Shape`] for more details.
+   */
+  Spatial = 0,
+  /**
+   * A temporal range, see [`Time`] for more details.
+   */
+  Temporal = 1,
+  /**
+   * A spatial range, see [`Frame`] for more details.
+   */
+  Frame = 2,
+  /**
+   * A textual range, see [`Text`] for more details.
+   */
+  Textual = 3,
+  /**
+   * A range identified by a specific identifier and value, see [`Item`] for more details.
+   */
+  Identified = 4
+}
+/**
+ * A spatial, temporal, frame, or textual range describing the region of interest.
+ */
+type Range = {
+  /**
+   * A frame range.
+   */
+  frame?: Frame;
+  /**
+   * A item identifier.
+   */
+  item?: Item;
+  /**
+   * A spatial range.
+   */
+  shape?: Shape;
+  /**
+   * A textual range.
+   */
+  text?: Text;
+  /**
+   * A temporal range.
+   */
+  time?: Time;
+  /**
+   * The type of range of interest.
+   */
+  type: RangeType;
+};
+/**
+ * Generated factory for {@link Range} record objects.
+ */
+declare const Range: Readonly<{
+  create: (partial: Partial<Range> & Required<Omit<Range, "frame" | "item" | "shape" | "text" | "time">>) => Range;
+  new: (partial: Partial<Range> & Required<Omit<Range, "frame" | "item" | "shape" | "text" | "time">>) => Range;
+  defaults: () => Partial<Range>;
+}>;
+/**
+ * A role describing the region.
+ */
+declare enum Role {
+  /**
+   * Arbitrary area worth identifying.
+   */
+  C2paAreaOfInterest = 0,
+  /**
+   * This area is all that is left after a crop action.
+   */
+  C2paCropped = 1,
+  /**
+   * This area has had edits applied to it.
+   */
+  C2paEdited = 2,
+  /**
+   * The area where an ingredient was placed/added.
+   */
+  C2paPlaced = 3,
+  /**
+   * Something in this area was redacted.
+   */
+  C2paRedacted = 4,
+  /**
+   * Area specific to a subject (human or not).
+   */
+  C2paSubjectArea = 5,
+  /**
+   * A range of information was removed/deleted.
+   */
+  C2paDeleted = 6,
+  /**
+   * Styling was applied to this area.
+   */
+  C2paStyled = 7,
+  /**
+   * Invisible watermarking was applied to this area for the purpose of soft binding.
+   */
+  C2paWatermarked = 8
+}
+/**
+ * A region of interest within an asset describing the change.
+ *
+ * This struct can be used from [`Action::changes`][crate::assertions::Action::changes],
+ * [`AssertionMetadata::region_of_interest`][crate::assertions::AssertionMetadata::region_of_interest], or
+ * [`SoftBindingScope::region`][crate::assertions::soft_binding::SoftBindingScope::region].
+ */
+type RegionOfInterest = {
+  /**
+   * A free-text string.
+   */
+  description?: string;
+  /**
+   * A free-text string representing a machine-readable, unique to this assertion, identifier for the region.
+   */
+  identifier?: string;
+  /**
+   * Nested metadata, as JSON: the reader's one recursive edge.
+   */
+  metadata?: Value;
+  /**
+   * A free-text string representing a human-readable name for the region which might be used in a user interface.
+   */
+  name?: string;
+  /**
+   * A range describing the region of interest for the specific asset.
+   */
+  region: Array<Range>;
+  /**
+   * A value from our controlled vocabulary or an entity-specific value (e.g., com.litware.coolArea) that represents
+   * the role of a region among other regions.
+   */
+  role?: Role;
+  /**
+   * A value from a controlled vocabulary such as <https://cv.iptc.org/newscodes/imageregiontype/> or an entity-specific
+   * value (e.g., com.litware.newType) that represents the type of thing(s) depicted by a region.
+   *
+   * Note this field serializes/deserializes into the name `type`.
+   */
+  type?: string;
+};
+/**
+ * Generated factory for {@link RegionOfInterest} record objects.
+ */
+declare const RegionOfInterest: Readonly<{
+  create: (partial: Partial<RegionOfInterest> & Required<Omit<RegionOfInterest, "description" | "identifier" | "metadata" | "name" | "role" | "type">>) => RegionOfInterest;
+  new: (partial: Partial<RegionOfInterest> & Required<Omit<RegionOfInterest, "description" | "identifier" | "metadata" | "name" | "role" | "type">>) => RegionOfInterest;
+  defaults: () => Partial<RegionOfInterest>;
+}>;
+/**
+ * A rating on an Assertion.
+ *
+ * See [C2PA Specification - Review Ratings](https://spec.c2pa.org/specifications/specifications/2.3/specs/C2PA_Specification.html#_review_ratings).
+ */
+type ReviewRating = {
+  code?: string;
+  explanation: string;
+  value: number;
+};
+/**
+ * Generated factory for {@link ReviewRating} record objects.
+ */
+declare const ReviewRating: Readonly<{
+  create: (partial: Partial<ReviewRating> & Required<Omit<ReviewRating, "code">>) => ReviewRating;
+  new: (partial: Partial<ReviewRating> & Required<Omit<ReviewRating, "code">>) => ReviewRating;
+  defaults: () => Partial<ReviewRating>;
+}>;
+/**
+ * The AssertionMetadata structure can be used as part of other assertions or on its own to reference others
+ */
+type AssertionMetadata = {
+  dataSource?: DataSource;
+  dateTime?: string;
+  localizations?: Array<Map<string, Map<string, string>>>;
+  reference?: HashedUri;
+  regionOfInterest?: RegionOfInterest;
+  reviewRatings?: Array<ReviewRating>;
+};
+/**
+ * Generated factory for {@link AssertionMetadata} record objects.
+ */
+declare const AssertionMetadata: Readonly<{
+  create: (partial: Partial<AssertionMetadata> & Required<Omit<AssertionMetadata, "dataSource" | "dateTime" | "localizations" | "reference" | "regionOfInterest" | "reviewRatings">>) => AssertionMetadata;
+  new: (partial: Partial<AssertionMetadata> & Required<Omit<AssertionMetadata, "dataSource" | "dateTime" | "localizations" | "reference" | "regionOfInterest" | "reviewRatings">>) => AssertionMetadata;
+  defaults: () => Partial<AssertionMetadata>;
+}>;
+/**
+ * `AssetType`
+ */
+type AssetType = {
+  type: string;
+  version?: string;
+};
+/**
+ * Generated factory for {@link AssetType} record objects.
+ */
+declare const AssetType: Readonly<{
+  create: (partial: Partial<AssetType> & Required<Omit<AssetType, "version">>) => AssetType;
+  new: (partial: Partial<AssetType> & Required<Omit<AssetType, "version">>) => AssetType;
+  defaults: () => Partial<AssetType>;
+}>;
+type SoftBinding = {
+  alg: string;
+  value: string;
+};
+/**
+ * Generated factory for {@link SoftBinding} record objects.
+ */
+declare const SoftBinding: Readonly<{
+  create: (partial: Partial<SoftBinding> & Required<Omit<SoftBinding, never>>) => SoftBinding;
+  new: (partial: Partial<SoftBinding> & Required<Omit<SoftBinding, never>>) => SoftBinding;
+  defaults: () => Partial<SoftBinding>;
+}>;
+/**
+ * Typealias from the type name used in the UDL file to the builtin type.  This
+ * is needed because the UDL type name is used in function/method signatures.
+ */
+type SimilarityScore = number;
+/**
+ * The class of binding a registry derived from an uploaded asset.
+ *
+ * Unlike [`SoftBinding`], this carries no value: the C2PA `byContent` response does not return
+ * one. The algorithm and class are still evidence because the request selects exactly that
+ * advertised algorithm.
+ */
+declare enum ContentBindingClass {
+  Fingerprint = 0,
+  Watermark = 1
+}
+/**
+ * One algorithm-specific piece of evidence returned by a content lookup.
+ */
+type ContentBindingEvidence = {
+  algorithm: string;
+  class: ContentBindingClass;
+  hint?: SoftBinding;
+  registryScore?: SimilarityScore;
+};
+/**
+ * Generated factory for {@link ContentBindingEvidence} record objects.
+ */
+declare const ContentBindingEvidence: Readonly<{
+  create: (partial: Partial<ContentBindingEvidence> & Required<Omit<ContentBindingEvidence, "hint" | "registryScore">>) => ContentBindingEvidence;
+  new: (partial: Partial<ContentBindingEvidence> & Required<Omit<ContentBindingEvidence, "hint" | "registryScore">>) => ContentBindingEvidence;
+  defaults: () => Partial<ContentBindingEvidence>;
+}>;
+declare enum CredentialOrigin_Tags {
+  Embedded = "Embedded",
+  RecoveredByFingerprint = "RecoveredByFingerprint",
+  RecoveredByWatermark = "RecoveredByWatermark",
+  RecoveredByContent = "RecoveredByContent"
+}
+/**
+ * FFI projection of the domain origin. The soft-binding DTO remains public and wire-shaped,
+ * while the domain value keeps its constructor invariant private.
+ */
+declare const CredentialOrigin: Readonly<{
+  instanceOf: (obj: any) => obj is CredentialOrigin;
+  Embedded: {
+    new (): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.Embedded;
+    };
+    "new"(): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.Embedded;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.Embedded;
+    };
+  };
+  RecoveredByFingerprint: {
+    new (inner: {
+      binding: SoftBinding;
+      registryScore?: SimilarityScore;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.RecoveredByFingerprint;
+      readonly inner: Readonly<{
+        binding: SoftBinding;
+        registryScore?: SimilarityScore;
+      }>;
+    };
+    "new"(inner: {
+      binding: SoftBinding;
+      registryScore?: SimilarityScore;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.RecoveredByFingerprint;
+      readonly inner: Readonly<{
+        binding: SoftBinding;
+        registryScore?: SimilarityScore;
+      }>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.RecoveredByFingerprint;
+      readonly inner: Readonly<{
+        binding: SoftBinding;
+        registryScore?: SimilarityScore;
+      }>;
+    };
+  };
+  RecoveredByWatermark: {
+    new (inner: {
+      binding: SoftBinding;
+      registryScore?: SimilarityScore;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.RecoveredByWatermark;
+      readonly inner: Readonly<{
+        binding: SoftBinding;
+        registryScore?: SimilarityScore;
+      }>;
+    };
+    "new"(inner: {
+      binding: SoftBinding;
+      registryScore?: SimilarityScore;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.RecoveredByWatermark;
+      readonly inner: Readonly<{
+        binding: SoftBinding;
+        registryScore?: SimilarityScore;
+      }>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.RecoveredByWatermark;
+      readonly inner: Readonly<{
+        binding: SoftBinding;
+        registryScore?: SimilarityScore;
+      }>;
+    };
+  };
+  RecoveredByContent: {
+    new (inner: {
+      discoveries: Array<ContentBindingEvidence>;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.RecoveredByContent;
+      readonly inner: Readonly<{
+        discoveries: Array<ContentBindingEvidence>;
+      }>;
+    };
+    "new"(inner: {
+      discoveries: Array<ContentBindingEvidence>;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.RecoveredByContent;
+      readonly inner: Readonly<{
+        discoveries: Array<ContentBindingEvidence>;
+      }>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "CredentialOrigin";
+      readonly tag: CredentialOrigin_Tags.RecoveredByContent;
+      readonly inner: Readonly<{
+        discoveries: Array<ContentBindingEvidence>;
+      }>;
+    };
+  };
+}>;
+/**
+ * FFI projection of the domain origin. The soft-binding DTO remains public and wire-shaped,
+ * while the domain value keeps its constructor invariant private.
+ */
+type CredentialOrigin = InstanceType<typeof CredentialOrigin['Embedded' | 'RecoveredByFingerprint' | 'RecoveredByWatermark' | 'RecoveredByContent']>;
+/**
+ * Assertions in C2PA can be stored in several formats
+ */
+declare enum ManifestAssertionKind {
+  Cbor = 0,
+  Json = 1,
+  Binary = 2,
+  Uri = 3
+}
+/**
+ * A labeled container for an Assertion value in a Manifest
+ */
+type ManifestAssertion = {
+  /**
+   * True if this assertion is attributed to the signer
+   * This maps to a created vs a gathered assertion. (defaults to false)
+   */
+  created?: boolean;
+  /**
+   * The data of the assertion as Value
+   */
+  data: Value;
+  /**
+   * There can be more than one assertion for any label
+   */
+  instance?: number;
+  /**
+   * The [ManifestAssertionKind] for this assertion (as stored in c2pa content)
+   */
+  kind?: ManifestAssertionKind;
+  /**
+   * An assertion label in reverse domain format
+   */
+  label: string;
+};
+/**
+ * Generated factory for {@link ManifestAssertion} record objects.
+ */
+declare const ManifestAssertion: Readonly<{
+  create: (partial: Partial<ManifestAssertion> & Required<Omit<ManifestAssertion, "created" | "instance" | "kind">>) => ManifestAssertion;
+  new: (partial: Partial<ManifestAssertion> & Required<Omit<ManifestAssertion, "created" | "instance" | "kind">>) => ManifestAssertion;
+  defaults: () => Partial<ManifestAssertion>;
+}>;
+/**
+ * A reference to a resource to be used in JSON serialization.
+ *
+ * The underlying data can be read as a stream via [`Reader::resource_to_stream`][crate::Reader::resource_to_stream].
+ */
+type ResourceRef = {
+  /**
+   * The algorithm used to hash the resource (if applicable).
+   */
+  alg?: string;
+  /**
+   * More detailed data types as defined in the C2PA spec.
+   */
+  dataTypes?: Array<AssetType>;
+  /**
+   * The mime type of the referenced resource.
+   */
+  format: string;
+  /**
+   * The hash of the resource (if applicable).
+   */
+  hash?: string;
+  /**
+   * A URI that identifies the resource as referenced from the manifest.
+   *
+   * This may be a JUMBF URI, a file path, a URL or any other string.
+   * Relative JUMBF URIs will be resolved with the manifest label.
+   * Relative file paths will be resolved with the base path if provided.
+   */
+  identifier: string;
+};
+/**
+ * Generated factory for {@link ResourceRef} record objects.
+ */
+declare const ResourceRef: Readonly<{
+  create: (partial: Partial<ResourceRef> & Required<Omit<ResourceRef, "alg" | "dataTypes" | "hash">>) => ResourceRef;
+  new: (partial: Partial<ResourceRef> & Required<Omit<ResourceRef, "alg" | "dataTypes" | "hash">>) => ResourceRef;
+  defaults: () => Partial<ResourceRef>;
+}>;
+declare enum UriOrResource_Tags {
+  ResourceRef = "ResourceRef",
+  HashedUri = "HashedUri"
+}
+/**
+ * `UriOrResource`
+ */
+declare const UriOrResource: Readonly<{
+  instanceOf: (obj: any) => obj is UriOrResource;
+  ResourceRef: {
+    new (v0: ResourceRef): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "UriOrResource";
+      readonly tag: UriOrResource_Tags.ResourceRef;
+      readonly inner: Readonly<[ResourceRef]>;
+    };
+    "new"(v0: ResourceRef): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "UriOrResource";
+      readonly tag: UriOrResource_Tags.ResourceRef;
+      readonly inner: Readonly<[ResourceRef]>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "UriOrResource";
+      readonly tag: UriOrResource_Tags.ResourceRef;
+      readonly inner: Readonly<[ResourceRef]>;
+    };
+  };
+  HashedUri: {
+    new (v0: HashedUri): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "UriOrResource";
+      readonly tag: UriOrResource_Tags.HashedUri;
+      readonly inner: Readonly<[HashedUri]>;
+    };
+    "new"(v0: HashedUri): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "UriOrResource";
+      readonly tag: UriOrResource_Tags.HashedUri;
+      readonly inner: Readonly<[HashedUri]>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "UriOrResource";
+      readonly tag: UriOrResource_Tags.HashedUri;
+      readonly inner: Readonly<[HashedUri]>;
+    };
+  };
+}>;
+/**
+ * `UriOrResource`
+ */
+type UriOrResource = InstanceType<typeof UriOrResource['ResourceRef' | 'HashedUri']>;
+/**
+ * Description of the claim generator, or the software used in generating the claim.
+ *
+ * This structure is also used for actions softwareAgent
+ */
+type ClaimGeneratorInfo = {
+  /**
+   * hashed URI to the icon (either embedded or remote)
+   */
+  icon?: UriOrResource;
+  /**
+   * A human readable string naming the claim_generator
+   */
+  name: string;
+  /**
+   * A human readable string of the OS the claim generator is running on.
+   * CrJSON schema uses `operating_system`; C2PA CBOR may use `schema.org.SoftwareApplication.operatingSystem`.
+   */
+  operatingSystem?: string;
+  /**
+   * The version of the specification used to produce this manifest (SemVer)
+   */
+  specVersion?: string;
+  /**
+   * A human readable string of the product's version
+   */
+  version?: string;
+};
+/**
+ * Generated factory for {@link ClaimGeneratorInfo} record objects.
+ */
+declare const ClaimGeneratorInfo: Readonly<{
+  create: (partial: Partial<ClaimGeneratorInfo> & Required<Omit<ClaimGeneratorInfo, "icon" | "operatingSystem" | "specVersion" | "version">>) => ClaimGeneratorInfo;
+  new: (partial: Partial<ClaimGeneratorInfo> & Required<Omit<ClaimGeneratorInfo, "icon" | "operatingSystem" | "specVersion" | "version">>) => ClaimGeneratorInfo;
+  defaults: () => Partial<ClaimGeneratorInfo>;
+}>;
+/**
+ * The relationship of the ingredient to the current asset.
+ */
+declare enum Relationship {
+  /**
+   * The current asset is derived from this ingredient.
+   */
+  ParentOf = 0,
+  /**
+   * The current asset is a part of this ingredient.
+   */
+  ComponentOf = 1,
+  /**
+   * The ingredient was used as an input to a computational process to create or modify the asset.
+   */
+  InputTo = 2
+}
+/**
+ * A `ValidationStatus` struct describes the validation status of a
+ * specific part of a manifest.
+ *
+ * See [Existing Manifests - C2PA Technical Specification](https://spec.c2pa.org/specifications/specifications/2.3/specs/C2PA_Specification.html#_existing_manifests).
+ */
+type ValidationStatus = {
+  code: string;
+  explanation?: string;
+  url?: string;
+};
+/**
+ * Generated factory for {@link ValidationStatus} record objects.
+ */
+declare const ValidationStatus: Readonly<{
+  create: (partial: Partial<ValidationStatus> & Required<Omit<ValidationStatus, "explanation" | "url">>) => ValidationStatus;
+  new: (partial: Partial<ValidationStatus> & Required<Omit<ValidationStatus, "explanation" | "url">>) => ValidationStatus;
+  defaults: () => Partial<ValidationStatus>;
+}>;
+/**
+ * Contains a set of success, informational, and failure validation status codes.
+ */
+type StatusCodes = {
+  /**
+   * An array of validation failure codes. May be empty.
+   */
+  failure: Array<ValidationStatus>;
+  /**
+   * An array of validation informational codes. May be empty.
+   */
+  informational: Array<ValidationStatus>;
+  /**
+   * An array of validation success codes. May be empty.
+   */
+  success: Array<ValidationStatus>;
+};
+/**
+ * Generated factory for {@link StatusCodes} record objects.
+ */
+declare const StatusCodes: Readonly<{
+  create: (partial: Partial<StatusCodes> & Required<Omit<StatusCodes, never>>) => StatusCodes;
+  new: (partial: Partial<StatusCodes> & Required<Omit<StatusCodes, never>>) => StatusCodes;
+  defaults: () => Partial<StatusCodes>;
+}>;
+/**
+ * Represents any changes or deltas between the current and previous validation results for an ingredient's manifest.
+ */
+type IngredientDeltaValidationResult = {
+  /**
+   * JUMBF URI reference to the ingredient assertion
+   */
+  ingredientAssertionUri: string;
+  /**
+   * Validation results for the ingredient's active manifest
+   */
+  validationDeltas: StatusCodes;
+};
+/**
+ * Generated factory for {@link IngredientDeltaValidationResult} record objects.
+ */
+declare const IngredientDeltaValidationResult: Readonly<{
+  create: (partial: Partial<IngredientDeltaValidationResult> & Required<Omit<IngredientDeltaValidationResult, never>>) => IngredientDeltaValidationResult;
+  new: (partial: Partial<IngredientDeltaValidationResult> & Required<Omit<IngredientDeltaValidationResult, never>>) => IngredientDeltaValidationResult;
+  defaults: () => Partial<IngredientDeltaValidationResult>;
+}>;
+/**
+ * A map of validation results for a manifest store.
+ *
+ * The map contains the validation results for the active manifest and any ingredient deltas.
+ * It is normal for there to be many
+ */
+type ValidationResults = {
+  /**
+   * Validation status codes for the ingredient's active manifest. Present if ingredient is a C2PA
+   * asset. Not present if the ingredient is not a C2PA asset.
+   */
+  activeManifest?: StatusCodes;
+  /**
+   * List of any changes/deltas between the current and previous validation results for each ingredient's
+   * manifest. Present if the the ingredient is a C2PA asset.
+   */
+  ingredientDeltas?: Array<IngredientDeltaValidationResult>;
+  /**
+   * The version of the specification against which the validation was performed (SemVer formatted string).
+   */
+  specVersion?: string;
+  /**
+   * URI to the trust list that was used to validate manifests signing certificate.
+   */
+  trustListUri?: string;
+};
+/**
+ * Generated factory for {@link ValidationResults} record objects.
+ */
+declare const ValidationResults: Readonly<{
+  create: (partial: Partial<ValidationResults> & Required<Omit<ValidationResults, "activeManifest" | "ingredientDeltas" | "specVersion" | "trustListUri">>) => ValidationResults;
+  new: (partial: Partial<ValidationResults> & Required<Omit<ValidationResults, "activeManifest" | "ingredientDeltas" | "specVersion" | "trustListUri">>) => ValidationResults;
+  defaults: () => Partial<ValidationResults>;
+}>;
+/**
+ * An `Ingredient` is any external asset that has been used in the creation of an asset.
+ */
+type Ingredient = {
+  /**
+   * The active manifest label (if one exists).
+   *
+   * If this ingredient has a [`ManifestStore`],
+   * this will hold the label of the active [`Manifest`].
+   *
+   * [`Manifest`]: crate::Manifest
+   * [`ManifestStore`]: crate::ManifestStore
+   */
+  activeManifest?: string;
+  /**
+   * A reference to the actual data of the ingredient.
+   */
+  data?: ResourceRef;
+  /**
+   * Additional information about the data's type to the ingredient V2 structure.
+   */
+  dataTypes?: Array<AssetType>;
+  /**
+   * Additional description of the ingredient.
+   */
+  description?: string;
+  /**
+   * One of the source types defined at <https://cv.iptc.org/newscodes/digitalsourcetype/>
+   * or in this specification. Cannot be combined with `activeManifest`.
+   */
+  digitalSourceType?: string;
+  /**
+   * Document ID from `xmpMM:DocumentID` in XMP metadata.
+   */
+  documentId?: string;
+  /**
+   * The format of the source file as a MIME type.
+   */
+  format?: string;
+  /**
+   * An optional hash of the asset to prevent duplicates.
+   */
+  hash?: string;
+  /**
+   * URI to an informational page about the ingredient or its data.
+   */
+  informationalUri?: string;
+  /**
+   * Instance ID from `xmpMM:InstanceID` in XMP metadata.
+   */
+  instanceId?: string;
+  /**
+   * The ingredient's label as assigned in the manifest.
+   */
+  label?: string;
+  /**
+   * A [`ManifestStore`] from the source asset extracted as a binary C2PA blob.
+   *
+   * [`ManifestStore`]: crate::ManifestStore
+   */
+  manifestData?: ResourceRef;
+  /**
+   * Any additional [`Metadata`] as defined in the C2PA spec.
+   *
+   * [`Metadata`]: crate::Metadata
+   */
+  metadata?: AssertionMetadata;
+  ocspResponses?: Array<ResourceRef>;
+  /**
+   * URI from `dcterms:provenance` in XMP metadata.
+   */
+  provenance?: string;
+  /**
+   * Set to `ParentOf` if this is the parent ingredient.
+   *
+   * There can only be one parent ingredient in the ingredients.
+   */
+  relationship: Relationship;
+  /**
+   * Soft binding algorithms that discovered this ingredient's active manifest, when it was
+   * found by a soft binding lookup rather than read out of the asset.
+   *
+   * Drives `softBindingAlgorithmsMatched` and the `softBindingsMatched` that C2PA requires
+   * beside it (C2PA 2.4 §18.16.14), which is derived rather than carried: the spec needs at least one algorithm
+   * whenever the flag is true, so a list and a flag that could disagree is not worth modelling.
+   */
+  softBindingAlgorithmsMatched?: Array<string>;
+  /**
+   * A thumbnail image capturing the visual state at the time of import.
+   *
+   * A tuple of thumbnail MIME format (for example `image/jpeg`) and binary bits of the image.
+   */
+  thumbnail?: ResourceRef;
+  /**
+   * A human-readable title, generally source filename.
+   */
+  title?: string;
+  /**
+   * Validation results (Ingredient.V3)
+   */
+  validationResults?: ValidationResults;
+  /**
+   * Validation status (Ingredient v1 & v2)
+   */
+  validationStatus?: Array<ValidationStatus>;
+};
+/**
+ * Generated factory for {@link Ingredient} record objects.
+ */
+declare const Ingredient: Readonly<{
+  create: (partial: Partial<Ingredient> & Required<Omit<Ingredient, "activeManifest" | "data" | "dataTypes" | "description" | "digitalSourceType" | "documentId" | "format" | "hash" | "informationalUri" | "instanceId" | "label" | "manifestData" | "metadata" | "ocspResponses" | "provenance" | "softBindingAlgorithmsMatched" | "thumbnail" | "title" | "validationResults" | "validationStatus">>) => Ingredient;
+  new: (partial: Partial<Ingredient> & Required<Omit<Ingredient, "activeManifest" | "data" | "dataTypes" | "description" | "digitalSourceType" | "documentId" | "format" | "hash" | "informationalUri" | "instanceId" | "label" | "manifestData" | "metadata" | "ocspResponses" | "provenance" | "softBindingAlgorithmsMatched" | "thumbnail" | "title" | "validationResults" | "validationStatus">>) => Ingredient;
+  defaults: () => Partial<Ingredient>;
+}>;
+/**
+ * JSON Schema proxy for [`SigningAlg`].
+ *
+ * `c2pa_raw_crypto::SigningAlg` intentionally does not depend on `schemars`,
+ * so it does not implement [`schemars::JsonSchema`]. SDK types that expose a
+ * `SigningAlg` in their JSON schema reference this mirror (whose variants match
+ * `SigningAlg`'s serialized form) via `#[schemars(with = "...")]`.
+ */
+declare enum SigningAlgSchema {
+  Es256 = 0,
+  Es384 = 1,
+  Es512 = 2,
+  Ps256 = 3,
+  Ps384 = 4,
+  Ps512 = 5,
+  Ed25519 = 6
+}
+/**
+ * Holds information about a signature
+ */
+type SignatureInfo = {
+  /**
+   * Human-readable issuing authority for this signature.
+   */
+  alg?: SigningAlgSchema;
+  /**
+   * The serial number of the certificate.
+   */
+  certSerialNumber?: string;
+  /**
+   * Human-readable for common name of this certificate.
+   */
+  commonName?: string;
+  /**
+   * Human-readable issuing authority for this signature.
+   */
+  issuer?: string;
+  /**
+   * Revocation status of the certificate.
+   */
+  revocationStatus?: boolean;
+  /**
+   * The time the signature was created.
+   */
+  time?: string;
+};
+/**
+ * Generated factory for {@link SignatureInfo} record objects.
+ */
+declare const SignatureInfo: Readonly<{
+  create: (partial: Partial<SignatureInfo> & Required<Omit<SignatureInfo, "alg" | "certSerialNumber" | "commonName" | "issuer" | "revocationStatus" | "time">>) => SignatureInfo;
+  new: (partial: Partial<SignatureInfo> & Required<Omit<SignatureInfo, "alg" | "certSerialNumber" | "commonName" | "issuer" | "revocationStatus" | "time">>) => SignatureInfo;
+  defaults: () => Partial<SignatureInfo>;
+}>;
+/**
+ * A Manifest represents all the information in a c2pa manifest
+ */
+type Manifest = {
+  /**
+   * A list of assertions
+   */
+  assertions: Array<ManifestAssertion>;
+  /**
+   * A User Agent formatted string identifying the software/hardware/system produced this claim
+   * Spaces are not allowed in names, versions can be specified with product/1.0 syntax.
+   */
+  claimGenerator?: string;
+  /**
+   * A list of claim generator info data identifying the software/hardware/system produced this claim.
+   */
+  claimGeneratorInfo?: Array<ClaimGeneratorInfo>;
+  /**
+   * The version of the claim, parsed from the claim label.
+   *
+   * For example:
+   * - `c2pa.claim.v2` -> 2
+   * - `c2pa.claim` -> 1
+   */
+  claimVersion?: number;
+  /**
+   * A List of verified credentials
+   */
+  credentials?: Array<Value>;
+  /**
+   * The format of the source file as a MIME type.
+   */
+  format?: string;
+  /**
+   * A List of ingredients
+   */
+  ingredients: Array<Ingredient>;
+  /**
+   * Instance ID from `xmpMM:InstanceID` in XMP metadata.
+   */
+  instanceId: string;
+  label?: string;
+  /**
+   * A list of user metadata for this claim.
+   */
+  metadata?: Array<AssertionMetadata>;
+  /**
+   * JUMBF URIs of assertions that were redacted by this manifest.
+   *
+   * Each entry has the form
+   * `self#jumbf=/c2pa/<manifest_label>/c2pa.assertions/<assertion_label>`
+   * and corresponds to an assertion that was intentionally removed from an
+   * ingredient manifest in the claim chain.
+   */
+  redactions?: Array<string>;
+  /**
+   * Signature data (only used for reporting)
+   */
+  signatureInfo?: SignatureInfo;
+  thumbnail?: ResourceRef;
+  /**
+   * A human-readable title, generally source filename.
+   */
+  title?: string;
+  /**
+   * Optional prefix added to the generated Manifest label.
+   * This is typically an internet domain name for the vendor (i.e. `adobe`).
+   */
+  vendor?: string;
+};
+/**
+ * Generated factory for {@link Manifest} record objects.
+ */
+declare const Manifest: Readonly<{
+  create: (partial: Partial<Manifest> & Required<Omit<Manifest, "claimGenerator" | "claimGeneratorInfo" | "claimVersion" | "credentials" | "format" | "label" | "metadata" | "redactions" | "signatureInfo" | "thumbnail" | "title" | "vendor">>) => Manifest;
+  new: (partial: Partial<Manifest> & Required<Omit<Manifest, "claimGenerator" | "claimGeneratorInfo" | "claimVersion" | "credentials" | "format" | "label" | "metadata" | "redactions" | "signatureInfo" | "thumbnail" | "title" | "vendor">>) => Manifest;
+  defaults: () => Partial<Manifest>;
+}>;
+/**
+ * Represents the levels of assurance a manifest store achieves when evaluated against the C2PA
+ * specifications structural, cryptographic, and trust requirements.
+ *
+ * See [Validation states - C2PA Technical Specification](https://spec.c2pa.org/specifications/specifications/2.3/specs/C2PA_Specification.html#_validation_states).
+ */
+declare enum ValidationState {
+  /**
+   * The manifest store fails to meet ValidationState::WellFormed requirements, meaning it cannot
+   * even be parsed or its basic structure is non-compliant.
+   *
+   * This case may also occur if validation is disabled in the SDK.
+   */
+  Invalid = 0,
+  /**
+   * The manifest store is well-formed and the cryptographic integrity checks succeed.
+   *
+   * See [Valid Manifest - C2PA Technical Specification](https://spec.c2pa.org/specifications/specifications/2.3/specs/C2PA_Specification.html#_valid_manifest).
+   */
+  Valid = 1,
+  /**
+   * The manifest store is valid and signed by a certificate that chains up to a trusted root or known
+   * authority in the trust list.
+   *
+   * See [Trusted Manifest - C2PA Technical Specification](https://spec.c2pa.org/specifications/specifications/2.3/specs/C2PA_Specification.html#_trusted_manifest).
+   */
+  Trusted = 2
+}
+/**
+ * Use a Reader to read and validate a manifest store.
+ */
+type ManifestStore = {
+  /**
+   * A label for the active (most recent) manifest in the store
+   */
+  activeManifest?: string;
+  /**
+   * A HashMap of Manifests
+   */
+  manifests: Map<string, Manifest>;
+  /**
+   * ValidationStatus generated when loading the ManifestStore from an asset
+   */
+  validationResults?: ValidationResults;
+  /**
+   * The validation state of the manifest store
+   */
+  validationState?: ValidationState;
+  /**
+   * ValidationStatus generated when loading the ManifestStore from an asset
+   */
+  validationStatus?: Array<ValidationStatus>;
+};
+/**
+ * Generated factory for {@link ManifestStore} record objects.
+ */
+declare const ManifestStore: Readonly<{
+  create: (partial: Partial<ManifestStore> & Required<Omit<ManifestStore, "activeManifest" | "validationResults" | "validationState" | "validationStatus">>) => ManifestStore;
+  new: (partial: Partial<ManifestStore> & Required<Omit<ManifestStore, "activeManifest" | "validationResults" | "validationState" | "validationStatus">>) => ManifestStore;
+  defaults: () => Partial<ManifestStore>;
+}>;
+declare enum FingerprintCheck_Tags {
+  NotNeeded = "NotNeeded",
+  NothingToCompare = "NothingToCompare",
+  Unsupported = "Unsupported",
+  Indeterminate = "Indeterminate",
+  Compared = "Compared"
+}
+/**
+ * Whether the asset's own fingerprint backs up a manifest that a watermark led to.
+ *
+ * C2PA 2.4 1.2.2.3: a watermark can be lifted from one asset onto another, so a mark alone does
+ * not establish that the manifest it resolves to describes THIS asset. The mitigation the spec
+ * gives is to compare a fingerprint computed from the asset against the one the recovered
+ * manifest records, and `watermark-and-fingerprint` ends on exactly that comparison.
+ *
+ * Reported rather than enforced: a transcode legitimately shifts a fingerprint, so where the line
+ * falls is the relying party's policy, not this SDK's. What the SDK owes them is the measurement.
+ */
+declare const FingerprintCheck: Readonly<{
+  instanceOf: (obj: any) => obj is FingerprintCheck;
+  NotNeeded: {
+    new (): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.NotNeeded;
+    };
+    "new"(): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.NotNeeded;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.NotNeeded;
+    };
+  };
+  NothingToCompare: {
+    new (): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.NothingToCompare;
+    };
+    "new"(): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.NothingToCompare;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.NothingToCompare;
+    };
+  };
+  Unsupported: {
+    new (inner: {
+      algorithm: string;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.Unsupported;
+      readonly inner: Readonly<{
+        algorithm: string;
+      }>;
+    };
+    "new"(inner: {
+      algorithm: string;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.Unsupported;
+      readonly inner: Readonly<{
+        algorithm: string;
+      }>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.Unsupported;
+      readonly inner: Readonly<{
+        algorithm: string;
+      }>;
+    };
+  };
+  Indeterminate: {
+    new (): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.Indeterminate;
+    };
+    "new"(): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.Indeterminate;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.Indeterminate;
+    };
+  };
+  Compared: {
+    new (inner: {
+      score: SimilarityScore;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.Compared;
+      readonly inner: Readonly<{
+        score: SimilarityScore;
+      }>;
+    };
+    "new"(inner: {
+      score: SimilarityScore;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.Compared;
+      readonly inner: Readonly<{
+        score: SimilarityScore;
+      }>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "FingerprintCheck";
+      readonly tag: FingerprintCheck_Tags.Compared;
+      readonly inner: Readonly<{
+        score: SimilarityScore;
+      }>;
+    };
+  };
+}>;
+/**
+ * Whether the asset's own fingerprint backs up a manifest that a watermark led to.
+ *
+ * C2PA 2.4 1.2.2.3: a watermark can be lifted from one asset onto another, so a mark alone does
+ * not establish that the manifest it resolves to describes THIS asset. The mitigation the spec
+ * gives is to compare a fingerprint computed from the asset against the one the recovered
+ * manifest records, and `watermark-and-fingerprint` ends on exactly that comparison.
+ *
+ * Reported rather than enforced: a transcode legitimately shifts a fingerprint, so where the line
+ * falls is the relying party's policy, not this SDK's. What the SDK owes them is the measurement.
+ */
+type FingerprintCheck = InstanceType<typeof FingerprintCheck['NotNeeded' | 'NothingToCompare' | 'Unsupported' | 'Indeterminate' | 'Compared']>;
+/**
+ * One `verify` result: the c2pa manifest store, plus where it came from: see [`asset::CredentialOrigin`],
+ * whose recovered variants carry the same `SoftBinding` record `Binder.derive` returns, so a
+ * derived binding and a recovering one are one type.
+ */
+type FoundCredential = {
+  /**
+   * The bytes behind every thumbnail the manifests reference, by that reference's
+   * `identifier`: each manifest's claim thumbnail and each ingredient's. The manifests state
+   * identifiers and no images, so this is what a chain draws from.
+   */
+  thumbnails: Map<string, ArrayBuffer>;
+  /**
+   * Where this credential came from. See [`asset::CredentialOrigin`].
+   */
+  origin: CredentialOrigin;
+  /**
+   * The c2pa manifest store: its manifests by label, the active one, and the
+   * validation state and results.
+   */
+  manifest: ManifestStore;
+  /**
+   * Whether the asset's own fingerprint backs up a mark that led here (C2PA 2.4 1.2.2.3).
+   */
+  fingerprintCheck: FingerprintCheck;
+};
+/**
+ * Generated factory for {@link FoundCredential} record objects.
+ */
+declare const FoundCredential: Readonly<{
+  create: (partial: Partial<FoundCredential> & Required<Omit<FoundCredential, never>>) => FoundCredential;
+  new: (partial: Partial<FoundCredential> & Required<Omit<FoundCredential, never>>) => FoundCredential;
+  defaults: () => Partial<FoundCredential>;
+}>;
+/**
+ * Whether the configured recovery sequence ran to a conclusive answer.
+ */
+declare enum RecoveryStatus {
+  NotRequested = 0,
+  NotFound = 1,
+  Recovered = 2,
+  /**
+   * No credential was recovered and at least one required attempt failed or was skipped.
+   */
+  Incomplete = 3
+}
+/**
+ * Why registry recovery did not complete cleanly, or why one candidate was omitted while another
+ * succeeded. Kept as data so a partial recovery never loses the rest of the lookup outcome.
+ */
+declare enum RecoveryIssueKind {
+  Binder = 0,
+  BindingQuery = 1,
+  QueryRefused = 2,
+  ContentQuery = 3,
+  Capabilities = 4,
+  ContentTooLarge = 5,
+  CandidateFetch = 6,
+  CandidateValidation = 7,
+  ResourceLimit = 8
+}
+/**
+ * One non-fatal recovery problem. `manifest_id` is present only for a returned candidate.
+ */
+type RecoveryIssue = {
+  kind: RecoveryIssueKind;
+  manifestId?: string;
+  message: string;
+};
+/**
+ * Generated factory for {@link RecoveryIssue} record objects.
+ */
+declare const RecoveryIssue: Readonly<{
+  create: (partial: Partial<RecoveryIssue> & Required<Omit<RecoveryIssue, "manifestId">>) => RecoveryIssue;
+  new: (partial: Partial<RecoveryIssue> & Required<Omit<RecoveryIssue, "manifestId">>) => RecoveryIssue;
+  defaults: () => Partial<RecoveryIssue>;
+}>;
+/**
+ * Registry recovery outcome, including the strongest successfully validated candidate and every
+ * non-fatal issue encountered on the way.
+ */
+type RecoverySummary = {
+  status: RecoveryStatus;
+  /**
+   * Index into [`AssetVerification::credentials`]. Ranking is strongest-first, so this is the
+   * C2PA golden-flow candidate rather than an implicit positional convention.
+   */
+  bestCredentialIndex?: number;
+  issues: Array<RecoveryIssue>;
+};
+/**
+ * Generated factory for {@link RecoverySummary} record objects.
+ */
+declare const RecoverySummary: Readonly<{
+  create: (partial: Partial<RecoverySummary> & Required<Omit<RecoverySummary, "bestCredentialIndex">>) => RecoverySummary;
+  new: (partial: Partial<RecoverySummary> & Required<Omit<RecoverySummary, "bestCredentialIndex">>) => RecoverySummary;
+  defaults: () => Partial<RecoverySummary>;
+}>;
+declare enum GoldenComparison_Tags {
+  NotRequested = "NotRequested",
+  NoEmbeddedManifest = "NoEmbeddedManifest",
+  NoRecoveredManifest = "NoRecoveredManifest",
+  Matches = "Matches",
+  Differs = "Differs",
+  Indeterminate = "Indeterminate"
+}
+/**
+ * Typed completion of C2PA 2.4's `watermark-golden` / `fingerprint-golden` final comparison.
+ */
+declare const GoldenComparison: Readonly<{
+  instanceOf: (obj: any) => obj is GoldenComparison;
+  NotRequested: {
+    new (): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.NotRequested;
+    };
+    "new"(): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.NotRequested;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.NotRequested;
+    };
+  };
+  NoEmbeddedManifest: {
+    new (): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.NoEmbeddedManifest;
+    };
+    "new"(): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.NoEmbeddedManifest;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.NoEmbeddedManifest;
+    };
+  };
+  NoRecoveredManifest: {
+    new (): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.NoRecoveredManifest;
+    };
+    "new"(): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.NoRecoveredManifest;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.NoRecoveredManifest;
+    };
+  };
+  Matches: {
+    new (inner: {
+      recoveredIndex: number;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.Matches;
+      readonly inner: Readonly<{
+        recoveredIndex: number;
+      }>;
+    };
+    "new"(inner: {
+      recoveredIndex: number;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.Matches;
+      readonly inner: Readonly<{
+        recoveredIndex: number;
+      }>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.Matches;
+      readonly inner: Readonly<{
+        recoveredIndex: number;
+      }>;
+    };
+  };
+  Differs: {
+    new (inner: {
+      recoveredIndex: number;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.Differs;
+      readonly inner: Readonly<{
+        recoveredIndex: number;
+      }>;
+    };
+    "new"(inner: {
+      recoveredIndex: number;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.Differs;
+      readonly inner: Readonly<{
+        recoveredIndex: number;
+      }>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.Differs;
+      readonly inner: Readonly<{
+        recoveredIndex: number;
+      }>;
+    };
+  };
+  Indeterminate: {
+    new (inner: {
+      recoveredIndex?: number;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.Indeterminate;
+      readonly inner: Readonly<{
+        recoveredIndex?: number;
+      }>;
+    };
+    new: (partial: Parameters<(partial: Partial<{
+      recoveredIndex?: number;
+    }> & Required<Omit<{
+      recoveredIndex?: number;
+    }, "recoveredIndex">>) => {
+      recoveredIndex?: number;
+    }>[0]) => {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.Indeterminate;
+      readonly inner: Readonly<{
+        recoveredIndex?: number;
+      }>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "GoldenComparison";
+      readonly tag: GoldenComparison_Tags.Indeterminate;
+      readonly inner: Readonly<{
+        recoveredIndex?: number;
+      }>;
+    };
+  };
+}>;
+/**
+ * Typed completion of C2PA 2.4's `watermark-golden` / `fingerprint-golden` final comparison.
+ */
+type GoldenComparison = InstanceType<typeof GoldenComparison['NotRequested' | 'NoEmbeddedManifest' | 'NoRecoveredManifest' | 'Matches' | 'Differs' | 'Indeterminate']>;
+/**
+ * Complete asset verification result, including conclusive/incomplete recovery state and the
+ * C2PA golden-flow comparison against the strongest recovered credential.
+ */
+type AssetVerification = {
+  credentials: Array<FoundCredential>;
+  recovery: RecoverySummary;
+  goldenComparison: GoldenComparison;
+};
+/**
+ * Generated factory for {@link AssetVerification} record objects.
+ */
+declare const AssetVerification: Readonly<{
+  create: (partial: Partial<AssetVerification> & Required<Omit<AssetVerification, never>>) => AssetVerification;
+  new: (partial: Partial<AssetVerification> & Required<Omit<AssetVerification, never>>) => AssetVerification;
+  defaults: () => Partial<AssetVerification>;
+}>;
+/**
+ * When [`AssetVerifier::verify_asset`] queries the registry.
+ */
+declare enum RecoveryPolicy {
+  /**
+   * Only when the asset carries no manifest of its own, the stripped or never-embedded copy
+   * whose credential lives only in the registry. An asset that is still signed costs no round
+   * trip, which is why this is the default.
+   */
+  WhenMissing = 0,
+  /**
+   * On every verify, alongside the embedded manifest, so the two can be compared.
+   *
+   * C2PA 2.4's `watermark-golden` and `fingerprint-golden` flows end on exactly that
+   * comparison, and it is the only thing that catches a manifest SUBSTITUTED under an
+   * untouched mark (use case UC3 in the spec's list, UC2 in ours): the replacement verifies
+   * perfectly on its own, and only disagrees with what the mark actually resolves to.
+   *
+   * It queries the registry on every verify, without making it load-bearing on the asset's own
+   * credential: the flow provides information about a substitution rather than gating the local
+   * manifest, so a registry that cannot be reached leaves [`RecoveryStatus::Incomplete`], the
+   * reason as a [`RecoveryIssue`], and [`GoldenComparison::Indeterminate`]. A caller for whom a
+   * cross-check that never ran must not pass for agreement branches on that status.
+   */
+  Always = 1
+}
+/**
+ * How far a recovery may go, which decides what leaves the caller.
+ *
+ * Separate from [`RecoveryPolicy`], which decides *when* a recovery runs: one names the trigger
+ * and the other the reach, and crossing them is what the two enums exist to keep legible.
+ */
+declare enum RegistryQueries {
+  /**
+   * Bindings this client derived, looked up by value. The asset never leaves the caller, which
+   * is what a verifier embedded in someone else's page needs: it can ask whether a code it
+   * computed is known without handing over what it computed the code from.
+   *
+   * A binding nobody local can derive is therefore unreachable, watermarks included, because
+   * detecting those is the registry's job and needs the asset.
+   */
+  Derived = 0,
+  /**
+   * Also `POST /matches/byContent` when no derived binding hits, which uploads the asset so the
+   * registry can derive the bindings its own deployment supports, detector-backed watermarks
+   * among them. The upload happens only on that miss, and only for an asset small enough to
+   * send.
+   */
+  DerivedThenContent = 1
+}
+/**
+ * Where the registry is, when to query it, and how far. One value rather than an endpoint beside
+ * loose flags, so a policy cannot be configured on a verifier that has nowhere to apply it.
+ */
+type RegistryOptions = {
+  /**
+   * Soft Binding Resolution API base URL (`https://registry.trylimbo.com`).
+   */
+  url: string;
+  /**
+   * Defaults to [`RecoveryPolicy::WhenMissing`].
+   */
+  recovery?: RecoveryPolicy;
+  /**
+   * Defaults to [`RegistryQueries::DerivedThenContent`].
+   */
+  queries?: RegistryQueries;
+};
+/**
+ * Generated factory for {@link RegistryOptions} record objects.
+ */
+declare const RegistryOptions: Readonly<{
+  create: (partial: Partial<RegistryOptions> & Required<Omit<RegistryOptions, "queries" | "recovery">>) => RegistryOptions;
+  new: (partial: Partial<RegistryOptions> & Required<Omit<RegistryOptions, "queries" | "recovery">>) => RegistryOptions;
+  defaults: () => Partial<RegistryOptions>;
+}>;
+/**
+ * Construction options for [`AssetVerifier::new`] (and the `AssetVerifier.create` JS
+ * binding). `trust_c2pa_anchors` defaults to `true` when omitted.
+ *
+ * One definition, all lanes: `#[binding]` derives the shapes directly here:
+ * tsify (camelCase, optional fields) on wasm, a `uniffi::Record` on the native
+ * `ffi` build, so there is no per-lane DTO copy. Off both lanes it is a plain struct.
+ */
+type AssetVerifierOptions = {
+  /**
+   * The registry to recover from. Omit for a verifier that only checks embedded manifests.
+   */
+  registry?: RegistryOptions;
+  /**
+   * PEM trust anchors for the caller's own issuers.
+   */
+  trustAnchors: Array<string>;
+  /**
+   * Also trust the bundled official C2PA anchors on top of `trust_anchors`.
+   * Defaults to `true`; set `false` to trust only `trust_anchors`.
+   */
+  trustC2paAnchors?: boolean;
+  /**
+   * Issuer DIDs whose CAWG identity (ICA) credentials count as validated, matched
+   * exactly against the credential issuer. Omitted or empty trusts no issuer: every
+   * identity assertion then reports `cawg.ica.untrusted_issuer` and withholds
+   * `cawg.ica.credential_valid`, which leaves the manifest's own validity untouched.
+   */
+  trustedIcaIssuers?: Array<string>;
+};
+/**
+ * Generated factory for {@link AssetVerifierOptions} record objects.
+ */
+declare const AssetVerifierOptions: Readonly<{
+  create: (partial: Partial<AssetVerifierOptions> & Required<Omit<AssetVerifierOptions, "registry" | "trustC2paAnchors" | "trustedIcaIssuers">>) => AssetVerifierOptions;
+  new: (partial: Partial<AssetVerifierOptions> & Required<Omit<AssetVerifierOptions, "registry" | "trustC2paAnchors" | "trustedIcaIssuers">>) => AssetVerifierOptions;
+  defaults: () => Partial<AssetVerifierOptions>;
+}>;
+/**
+ * Everything one [`Binder::derive`] needs beyond the asset. `format` overrides the format sniffed
+ * from the leading bytes.
+ */
+type DeriveOptions = {
+  format?: string;
+};
+/**
+ * Generated factory for {@link DeriveOptions} record objects.
+ */
+declare const DeriveOptions: Readonly<{
+  create: (partial: Partial<DeriveOptions> & Required<Omit<DeriveOptions, "format">>) => DeriveOptions;
+  new: (partial: Partial<DeriveOptions> & Required<Omit<DeriveOptions, "format">>) => DeriveOptions;
+  defaults: () => Partial<DeriveOptions>;
+}>;
+/**
+ * One `google.rpc.BadRequest.FieldViolation`: a request field that failed a constraint.
+ */
+type FieldViolation = {
+  /**
+   * A dotted proto path to the offending field (`""` for a message-level rule).
+   */
+  field: string;
+  /**
+   * Human-readable explanation of the violation.
+   */
+  description: string;
+  /**
+   * The constraint id that failed (a protovalidate/CEL rule id), stable across releases.
+   */
+  reason: string;
+};
+/**
+ * Generated factory for {@link FieldViolation} record objects.
+ */
+declare const FieldViolation: Readonly<{
+  create: (partial: Partial<FieldViolation> & Required<Omit<FieldViolation, never>>) => FieldViolation;
+  new: (partial: Partial<FieldViolation> & Required<Omit<FieldViolation, never>>) => FieldViolation;
+  defaults: () => Partial<FieldViolation>;
+}>;
+/**
+ * Whether a code is a success, an informational note, or a failure.
+ */
+declare enum ValidationCodeKind {
+  Success = 0,
+  Informational = 1,
+  Failure = 2
+}
+/**
+ * One C2PA validation status entry (spec §15.3).
+ */
+type ValidationCode = {
+  /**
+   * C2PA validation status string (e.g. `signingCredential.trusted`).
+   */
+  code: string;
+  kind: ValidationCodeKind;
+};
+/**
+ * Generated factory for {@link ValidationCode} record objects.
+ */
+declare const ValidationCode: Readonly<{
+  create: (partial: Partial<ValidationCode> & Required<Omit<ValidationCode, never>>) => ValidationCode;
+  new: (partial: Partial<ValidationCode> & Required<Omit<ValidationCode, never>>) => ValidationCode;
+  defaults: () => Partial<ValidationCode>;
+}>;
+/**
+ * A session signing key from the init manifest's roster (spec §19.4.4).
+ */
+type SessionKeySummary = {
+  /**
+   * Identifier of the session signing key.
+   */
+  keyId: ArrayBuffer;
+  /**
+   * The session key's public half (SEC1-encoded bytes).
+   */
+  publicKey: ArrayBuffer;
+};
+/**
+ * Generated factory for {@link SessionKeySummary} record objects.
+ */
+declare const SessionKeySummary: Readonly<{
+  create: (partial: Partial<SessionKeySummary> & Required<Omit<SessionKeySummary, never>>) => SessionKeySummary;
+  new: (partial: Partial<SessionKeySummary> & Required<Omit<SessionKeySummary, never>>) => SessionKeySummary;
+  defaults: () => Partial<SessionKeySummary>;
+}>;
+/**
+ * Outcome of validating a stream's init segment.
+ */
+type InitValidation = {
+  /**
+   * The init manifest's C2PA validation state (spec §14.3). Read from
+   * `Reader::validation_state()`, so unlike `manifest.validation_state` it is
+   * never absent.
+   */
+  state: ValidationState;
+  codes: Array<ValidationCode>;
+  /**
+   * The init segment's c2pa manifest store.
+   */
+  manifest: ManifestStore;
+  sessionKeys: Array<SessionKeySummary>;
+};
+/**
+ * Generated factory for {@link InitValidation} record objects.
+ */
+declare const InitValidation: Readonly<{
+  create: (partial: Partial<InitValidation> & Required<Omit<InitValidation, never>>) => InitValidation;
+  new: (partial: Partial<InitValidation> & Required<Omit<InitValidation, never>>) => InitValidation;
+  defaults: () => Partial<InitValidation>;
+}>;
+/**
+ * Timing facts carried by a media segment's container.
+ */
+type SegmentTiming = {
+  /**
+   * Media segment sequence number (exact below 2^53).
+   */
+  sequenceNumber: bigint;
+  /**
+   * MP4 timescale (ticks per second) for this segment's timing, if present.
+   */
+  timescale?: number;
+  /**
+   * Segment duration in seconds, if the container reports it.
+   */
+  eventDurationSecs?: number;
+};
+/**
+ * Generated factory for {@link SegmentTiming} record objects.
+ */
+declare const SegmentTiming: Readonly<{
+  create: (partial: Partial<SegmentTiming> & Required<Omit<SegmentTiming, "eventDurationSecs" | "timescale">>) => SegmentTiming;
+  new: (partial: Partial<SegmentTiming> & Required<Omit<SegmentTiming, "eventDurationSecs" | "timescale">>) => SegmentTiming;
+  defaults: () => Partial<SegmentTiming>;
+}>;
+/**
+ * Outcome of validating a media segment against its stream's init.
+ */
+type MediaValidation = {
+  valid: boolean;
+  codes: Array<ValidationCode>;
+  keyId: ArrayBuffer;
+  timing: SegmentTiming;
+  manifestId: string;
+};
+/**
+ * Generated factory for {@link MediaValidation} record objects.
+ */
+declare const MediaValidation: Readonly<{
+  create: (partial: Partial<MediaValidation> & Required<Omit<MediaValidation, never>>) => MediaValidation;
+  new: (partial: Partial<MediaValidation> & Required<Omit<MediaValidation, never>>) => MediaValidation;
+  defaults: () => Partial<MediaValidation>;
+}>;
+/**
+ * A byte range holding a bare C2PA manifest store, or reserved for one. A record of
+ * primitives, so a plugin in its OWN UniFFI namespace declares a structurally identical
+ * one and the two cross the boundary without sharing a Rust type.
+ */
+type Region = {
+  offset: bigint;
+  length: bigint;
+};
+/**
+ * Generated factory for {@link Region} record objects.
+ */
+declare const Region: Readonly<{
+  create: (partial: Partial<Region> & Required<Omit<Region, never>>) => Region;
+  new: (partial: Partial<Region> & Required<Omit<Region, never>>) => Region;
+  defaults: () => Partial<Region>;
+}>;
+/**
+ * Construction options for [`StreamVerifier::new`] (and the `StreamVerifier.create`
+ * JS binding). `trust_c2pa_anchors` defaults to `true` when omitted.
+ *
+ * `#[binding]` derives the wasm shape (`trustC2paAnchors` camelCase, optional) and,
+ * with `ffi`, a `uniffi::Record` for the native `StreamVerifier.create` binding, so there
+ * is no per-lane DTO copy. Off both lanes it is a plain struct.
+ */
+type StreamVerifierOptions = {
+  /**
+   * PEM trust anchors for the caller's own issuers.
+   */
+  trustAnchors: Array<string>;
+  /**
+   * Also trust the bundled official C2PA anchors on top of `trust_anchors`.
+   * Defaults to `true`; set `false` to trust only `trust_anchors`.
+   */
+  trustC2paAnchors?: boolean;
+  /**
+   * Issuer DIDs whose CAWG identity (ICA) credentials count as validated, matched
+   * exactly against the credential issuer. Omitted or empty trusts no issuer: an
+   * identity assertion on the init segment's manifest then reports
+   * `cawg.ica.untrusted_issuer` and withholds `cawg.ica.credential_valid`.
+   */
+  trustedIcaIssuers?: Array<string>;
+  /**
+   * How far a segment's timestamp may sit from wall-clock before it is rejected as
+   * skewed. Defaults to [`DEFAULT_SEGMENT_SKEW_TOLERANCE_SECS`]. A deployment whose
+   * encoder clock drifts further than that needs this rather than a fork.
+   */
+  segmentSkewToleranceSecs?: bigint;
+};
+/**
+ * Generated factory for {@link StreamVerifierOptions} record objects.
+ */
+declare const StreamVerifierOptions: Readonly<{
+  create: (partial: Partial<StreamVerifierOptions> & Required<Omit<StreamVerifierOptions, "segmentSkewToleranceSecs" | "trustC2paAnchors" | "trustedIcaIssuers">>) => StreamVerifierOptions;
+  new: (partial: Partial<StreamVerifierOptions> & Required<Omit<StreamVerifierOptions, "segmentSkewToleranceSecs" | "trustC2paAnchors" | "trustedIcaIssuers">>) => StreamVerifierOptions;
+  defaults: () => Partial<StreamVerifierOptions>;
+}>;
+/**
+ * A canonical gRPC/Connect status code: the coarse, closed failure class.
+ *
+ * The wasm lane projects this as the Connect `snake_case` string, so a consumer
+ * narrows on `err.code === "resource_exhausted"`; the native lane projects an enum.
+ */
+declare enum Code {
+  Canceled = 0,
+  Unknown = 1,
+  InvalidArgument = 2,
+  DeadlineExceeded = 3,
+  NotFound = 4,
+  AlreadyExists = 5,
+  PermissionDenied = 6,
+  ResourceExhausted = 7,
+  FailedPrecondition = 8,
+  Aborted = 9,
+  OutOfRange = 10,
+  Unimplemented = 11,
+  Internal = 12,
+  Unavailable = 13,
+  DataLoss = 14,
+  Unauthenticated = 15
+}
+declare enum SdkError_Tags {
+  Reason = "Reason",
+  Invalid = "Invalid",
+  Status = "Status"
+}
+/**
+ * The error every SDK call throws: a decoded `google.rpc.Status`, discriminated
+ * as a semantic reason, a request validation, or a bare status. `code` and `message`
+ * are common to every variant.
+ */
+declare const SdkError: Readonly<{
+  instanceOf: (obj: any) => obj is SdkError;
+  Reason: {
+    new (inner: {
+      code: Code;
+      message: string;
+      reason: string;
+      domain: string;
+      metadata: Map<string, string>;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Reason;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+        reason: string;
+        domain: string;
+        metadata: Map<string, string>;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    "new"(inner: {
+      code: Code;
+      message: string;
+      reason: string;
+      domain: string;
+      metadata: Map<string, string>;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Reason;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+        reason: string;
+        domain: string;
+        metadata: Map<string, string>;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Reason;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+        reason: string;
+        domain: string;
+        metadata: Map<string, string>;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    hasInner(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Reason;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+        reason: string;
+        domain: string;
+        metadata: Map<string, string>;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    getInner(obj: {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Reason;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+        reason: string;
+        domain: string;
+        metadata: Map<string, string>;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    }): Readonly<{
+      code: Code;
+      message: string;
+      reason: string;
+      domain: string;
+      metadata: Map<string, string>;
+    }>;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+  };
+  Invalid: {
+    new (inner: {
+      code: Code;
+      message: string;
+      fieldViolations: Array<FieldViolation>;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Invalid;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+        fieldViolations: Array<FieldViolation>;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    "new"(inner: {
+      code: Code;
+      message: string;
+      fieldViolations: Array<FieldViolation>;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Invalid;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+        fieldViolations: Array<FieldViolation>;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Invalid;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+        fieldViolations: Array<FieldViolation>;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    hasInner(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Invalid;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+        fieldViolations: Array<FieldViolation>;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    getInner(obj: {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Invalid;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+        fieldViolations: Array<FieldViolation>;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    }): Readonly<{
+      code: Code;
+      message: string;
+      fieldViolations: Array<FieldViolation>;
+    }>;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+  };
+  Status: {
+    new (inner: {
+      code: Code;
+      message: string;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Status;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    "new"(inner: {
+      code: Code;
+      message: string;
+    }): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Status;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Status;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    hasInner(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Status;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    getInner(obj: {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SdkError";
+      readonly tag: SdkError_Tags.Status;
+      readonly inner: Readonly<{
+        code: Code;
+        message: string;
+      }>;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    }): Readonly<{
+      code: Code;
+      message: string;
+    }>;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+  };
+}>;
+/**
+ * The error every SDK call throws: a decoded `google.rpc.Status`, discriminated
+ * as a semantic reason, a request validation, or a bare status. `code` and `message`
+ * are common to every variant.
+ */
+type SdkError = InstanceType<typeof SdkError['Reason' | 'Invalid' | 'Status']>;
+/**
+ * The host-supplied ranged reader: `length()` returns the asset size in bytes, `read_at`
+ * reads `length` bytes starting at `offset`. Each call crosses the FFI boundary, and the
+ * caller controls the backing store (memory, file, S3, HTTP, custom).
+ *
+ * # Both methods are async
+ *
+ * Because storage is: an object store is a round trip, and so is anything behind `fetch`. A
+ * synchronous `read_at` forces every such caller to make the asset local first, which is a
+ * whole copy of a file that may be hundreds of gigabytes, to answer reads the SDK was going to
+ * make one window at a time anyway. Implement this over `aiobotocore`, an S3 client, a ranged
+ * `fetch`, or a plain file, and await whatever it takes.
+ *
+ * The SDK never calls back into the thread that called it (see [`task`](super::task)), so an
+ * implementation is free to be as slow as its storage is.
+ *
+ * # Both methods are fallible
+ *
+ * They have to be: an infallible `read_at` can only report a failed read as a short one, which
+ * is indistinguishable from a legitimate end of file, so an S3 timeout would silently verify or
+ * sign a truncated asset.
+ */
+interface RangeSource {
+  length(asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<bigint>;
+  readAt(offset: bigint, length: number, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<ArrayBuffer>;
+}
+/**
+ * The host-supplied ranged reader: `length()` returns the asset size in bytes, `read_at`
+ * reads `length` bytes starting at `offset`. Each call crosses the FFI boundary, and the
+ * caller controls the backing store (memory, file, S3, HTTP, custom).
+ *
+ * # Both methods are async
+ *
+ * Because storage is: an object store is a round trip, and so is anything behind `fetch`. A
+ * synchronous `read_at` forces every such caller to make the asset local first, which is a
+ * whole copy of a file that may be hundreds of gigabytes, to answer reads the SDK was going to
+ * make one window at a time anyway. Implement this over `aiobotocore`, an S3 client, a ranged
+ * `fetch`, or a plain file, and await whatever it takes.
+ *
+ * The SDK never calls back into the thread that called it (see [`task`](super::task)), so an
+ * implementation is free to be as slow as its storage is.
+ *
+ * # Both methods are fallible
+ *
+ * They have to be: an infallible `read_at` can only report a failed read as a short one, which
+ * is indistinguishable from a legitimate end of file, so an S3 timeout would silently verify or
+ * sign a truncated asset.
+ */
+declare class RangeSourceImpl extends UniffiAbstractObject implements RangeSource {
+  readonly [uniffiTypeNameSymbol] = "RangeSourceImpl";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  private constructor();
+  length(asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<bigint>;
+  readAt(offset: bigint, length: number, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<ArrayBuffer>;
+  uniffiDestroy(): void;
+  static instanceOf(obj_: any): obj_ is RangeSourceImpl;
+}
+/**
+ * A soft-binding binder: how a recoverable binding is derived from an asset. Put these inside the
+ * issuer's manifest mode to sign and index under them, and pass them in verify options to recover.
+ */
+interface BinderLike {
+  /**
+   * This binder's binding for `source`, or `None` when there is none. `format` overrides
+   * the format sniffed from the leading bytes.
+   *
+   * `None` and an error mean different things: `None` is "no binding here", an error is
+   * "the question could not be answered", so a binder that failed never reads as an
+   * unmarked asset.
+   *
+   * # Errors
+   *
+   * An unreadable source, or a binder that could not answer.
+   */
+  derive(source: RangeSource, options: DeriveOptions, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<SoftBinding | undefined>;
+}
+/**
+ * @deprecated Use `BinderLike` instead.
+ */
+type BinderInterface = BinderLike;
+/**
+ * A soft-binding binder: how a recoverable binding is derived from an asset. Put these inside the
+ * issuer's manifest mode to sign and index under them, and pass them in verify options to recover.
+ */
+declare class Binder extends UniffiAbstractObject implements BinderLike {
+  readonly [uniffiTypeNameSymbol] = "Binder";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  private constructor();
+  /**
+   * A binding you already hold, such as an out-of-band video ISCC. Reads nothing.
+   */
+  static held(binding: SoftBinding): BinderLike;
+  /**
+   * Local ISCC Image-Code for supported image formats.
+   */
+  static iscc(): BinderLike;
+  /**
+   * This binder's binding for `source`, or `None` when there is none. `format` overrides
+   * the format sniffed from the leading bytes.
+   *
+   * `None` and an error mean different things: `None` is "no binding here", an error is
+   * "the question could not be answered", so a binder that failed never reads as an
+   * unmarked asset.
+   *
+   * # Errors
+   *
+   * An unreadable source, or a binder that could not answer.
+   */
+  derive(source: RangeSource, options: DeriveOptions, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<SoftBinding | undefined>;
+  uniffiDestroy(): void;
+  static instanceOf(obj_: any): obj_ is Binder;
+}
+/**
+ * The read surface a plugin implements. Implemented by the CALLER, in Rust
+ * behind its own cdylib or directly in the host language, and handed to `verify`.
+ *
+ * Every method is given the asset as a [`RangeSource`], so a plugin never opens its own
+ * view and the bytes it parses are the bytes the core hashes.
+ */
+interface PluginRead {
+  /**
+   * The media types this plugin owns: its dispatch set, declared as data. The core
+   * asserts a [`sniff`](Self::sniff) result is a member of this list.
+   */
+  mediaTypes(): Array<string>;
+  /**
+   * Recognize the format from the real asset, or `None` to decline it.
+   */
+  sniff(src: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<string | undefined>;
+  /**
+   * The manifest window(s), or empty when none is present. MUST be byte-identical
+   * regardless of slot contents (empty at sign, filled after embed, zeroed after strip).
+   */
+  locate(src: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<Array<Region>>;
+}
+/**
+ * The plugins one `verify` call may dispatch to. Rust-backed on purpose: see
+ * the module docs for why a plain sequence of foreign objects cannot cross today.
+ */
+interface PluginRegistryLike {
+  /**
+   * Whether no plugin is registered, meaning a c2pa-only verify.
+   *
+   * # Errors
+   *
+   * `Internal` when the registry lock was poisoned by a panicking plugin.
+   */
+  isEmpty(): boolean;
+  /**
+   * How many plugins are registered.
+   *
+   * # Errors
+   *
+   * `Internal` when the registry lock was poisoned by a panicking plugin.
+   */
+  len(): number;
+  /**
+   * Add one plugin. The first registered whose `sniff` hits owns the asset; `c2pa`
+   * remains the built-in fallback when none does. Verifying dispatches on content, not on
+   * a declared format: there is no trustworthy declaration at verify time.
+   *
+   * # Errors
+   *
+   * `Internal` when the registry lock was poisoned by a panicking plugin.
+   */
+  register(plugin: PluginRead): void;
+}
+/**
+ * @deprecated Use `PluginRegistryLike` instead.
+ */
+type PluginRegistryInterface = PluginRegistryLike;
+/**
+ * The plugins one `verify` call may dispatch to. Rust-backed on purpose: see
+ * the module docs for why a plain sequence of foreign objects cannot cross today.
+ */
+declare class PluginRegistry extends UniffiAbstractObject implements PluginRegistryLike {
+  readonly [uniffiTypeNameSymbol] = "PluginRegistry";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  constructor();
+  /**
+   * Whether no plugin is registered, meaning a c2pa-only verify.
+   *
+   * # Errors
+   *
+   * `Internal` when the registry lock was poisoned by a panicking plugin.
+   */
+  isEmpty(): boolean;
+  /**
+   * How many plugins are registered.
+   *
+   * # Errors
+   *
+   * `Internal` when the registry lock was poisoned by a panicking plugin.
+   */
+  len(): number;
+  /**
+   * Add one plugin. The first registered whose `sniff` hits owns the asset; `c2pa`
+   * remains the built-in fallback when none does. Verifying dispatches on content, not on
+   * a declared format: there is no trustworthy declaration at verify time.
+   *
+   * # Errors
+   *
+   * `Internal` when the registry lock was poisoned by a panicking plugin.
+   */
+  register(plugin: PluginRead): void;
+  uniffiDestroy(): void;
+  static instanceOf(obj_: any): obj_ is PluginRegistry;
+}
+/**
+ * Everything one [`AssetVerifier::verify`] needs beyond the asset.
+ *
+ * `binders` composes soft-binding recovery after the embedded pass, tried in order,
+ * first hit wins; pass `[]` for none. `plugins` carries the caller's plugins for non-c2pa formats
+ * (e.g. MXF); a built-in C2PA media format needs none.
+ */
+type VerifyOptions = {
+  binders: Array<BinderLike>;
+  plugins?: PluginRegistryLike;
+};
+/**
+ * Generated factory for {@link VerifyOptions} record objects.
+ */
+declare const VerifyOptions: Readonly<{
+  create: (partial: Partial<VerifyOptions> & Required<Omit<VerifyOptions, "plugins">>) => VerifyOptions;
+  new: (partial: Partial<VerifyOptions> & Required<Omit<VerifyOptions, "plugins">>) => VerifyOptions;
+  defaults: () => Partial<VerifyOptions>;
+}>;
+declare enum SegmentValidation_Tags {
+  Init = "Init",
+  Media = "Media",
+  Unknown = "Unknown"
+}
+/**
+ * Result of `StreamValidation.validate`.
+ */
+declare const SegmentValidation: Readonly<{
+  instanceOf: (obj: any) => obj is SegmentValidation;
+  Init: {
+    new (v0: InitValidation): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SegmentValidation";
+      readonly tag: SegmentValidation_Tags.Init;
+      readonly inner: Readonly<[InitValidation]>;
+    };
+    "new"(v0: InitValidation): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SegmentValidation";
+      readonly tag: SegmentValidation_Tags.Init;
+      readonly inner: Readonly<[InitValidation]>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SegmentValidation";
+      readonly tag: SegmentValidation_Tags.Init;
+      readonly inner: Readonly<[InitValidation]>;
+    };
+  };
+  Media: {
+    new (v0: MediaValidation): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SegmentValidation";
+      readonly tag: SegmentValidation_Tags.Media;
+      readonly inner: Readonly<[MediaValidation]>;
+    };
+    "new"(v0: MediaValidation): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SegmentValidation";
+      readonly tag: SegmentValidation_Tags.Media;
+      readonly inner: Readonly<[MediaValidation]>;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SegmentValidation";
+      readonly tag: SegmentValidation_Tags.Media;
+      readonly inner: Readonly<[MediaValidation]>;
+    };
+  };
+  Unknown: {
+    new (): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SegmentValidation";
+      readonly tag: SegmentValidation_Tags.Unknown;
+    };
+    "new"(): {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SegmentValidation";
+      readonly tag: SegmentValidation_Tags.Unknown;
+    };
+    instanceOf(obj: any): obj is {
+      /**
+       * @private
+       * This field is private and should not be used, use `tag` instead.
+       */
+      readonly [uniffiTypeNameSymbol]: "SegmentValidation";
+      readonly tag: SegmentValidation_Tags.Unknown;
+    };
+  };
+}>;
+/**
+ * Result of `StreamValidation.validate`.
+ */
+type SegmentValidation = InstanceType<typeof SegmentValidation['Init' | 'Media' | 'Unknown']>;
+/**
+ * A C2PA asset verifier bound to a trust configuration. Construct once, verify many.
+ */
+interface AssetVerifierLike {
+  /**
+   * Verify an asset from a [`RangeSource`] (the host's ranged reader). `binders`
+   * compose soft-binding recovery after the embedded pass, tried in order,
+   * first hit wins; pass `[]` for none. `plugins` carries the caller's
+   * plugins for non-c2pa formats (e.g. MXF); pass an empty `PluginRegistry` for a
+   * built-in C2PA media format. The SDK links no plugin itself. Returns embedded/recovered
+   * credentials plus typed recovery and golden-comparison outcomes.
+   *
+   * # Errors
+   *
+   * `READER_INVALID` when the source can't be read/parsed, or a registry failure
+   * involving the asset backend, registry, or a fetched manifest. Local binder faults,
+   * refused queries, and skipped oversized uploads are retained in the recovery summary.
+   */
+  verify(source: RangeSource, options: VerifyOptions, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<AssetVerification>;
+}
+/**
+ * @deprecated Use `AssetVerifierLike` instead.
+ */
+type AssetVerifierInterface = AssetVerifierLike;
+/**
+ * A C2PA asset verifier bound to a trust configuration. Construct once, verify many.
+ */
+declare class AssetVerifier extends UniffiAbstractObject implements AssetVerifierLike {
+  readonly [uniffiTypeNameSymbol] = "AssetVerifier";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  private constructor();
+  /**
+   * Build a verifier from [`AssetVerifierOptions`].
+   *
+   * # Errors
+   *
+   * `TRUST_CONFIG_INVALID` when the trust anchors can't be parsed.
+   */
+  static create(options: AssetVerifierOptions): AssetVerifierLike;
+  /**
+   * Verify an asset from a [`RangeSource`] (the host's ranged reader). `binders`
+   * compose soft-binding recovery after the embedded pass, tried in order,
+   * first hit wins; pass `[]` for none. `plugins` carries the caller's
+   * plugins for non-c2pa formats (e.g. MXF); pass an empty `PluginRegistry` for a
+   * built-in C2PA media format. The SDK links no plugin itself. Returns embedded/recovered
+   * credentials plus typed recovery and golden-comparison outcomes.
+   *
+   * # Errors
+   *
+   * `READER_INVALID` when the source can't be read/parsed, or a registry failure
+   * involving the asset backend, registry, or a fetched manifest. Local binder faults,
+   * refused queries, and skipped oversized uploads are retained in the recovery summary.
+   */
+  verify(source: RangeSource, options: VerifyOptions, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<AssetVerification>;
+  uniffiDestroy(): void;
+  static instanceOf(obj_: any): obj_ is AssetVerifier;
+}
+/**
+ * A [`RangeSource`] over a local file, opened and read by the SDK itself.
+ *
+ * The only source whose bytes never enter the host language. The other two both put the asset
+ * through it: a [`RangeSource`] written in the host is awaited for every window, and
+ * [`MemorySource`] avoids that only by holding the whole asset and copying it across the
+ * boundary to get there. A path costs neither, so the reads happen on the same thread that is
+ * already hashing, with no crossing at all.
+ *
+ * That is what makes the size ceilings stop applying: there is no byte array to count in an
+ * `i32` and nothing resident, so a multi-GB master reads at the disk's speed rather than the
+ * host thread's.
+ *
+ * This is an implementation of the [`RangeSource`] interface, not a way around it: the SDK still
+ * only ever asks for the ranges it needs, and no entry point takes a path.
+ */
+interface FileSourceLike {
+  length(asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<bigint>;
+  readAt(offset: bigint, length: number, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<ArrayBuffer>;
+}
+/**
+ * @deprecated Use `FileSourceLike` instead.
+ */
+type FileSourceInterface = FileSourceLike;
+/**
+ * A [`RangeSource`] over a local file, opened and read by the SDK itself.
+ *
+ * The only source whose bytes never enter the host language. The other two both put the asset
+ * through it: a [`RangeSource`] written in the host is awaited for every window, and
+ * [`MemorySource`] avoids that only by holding the whole asset and copying it across the
+ * boundary to get there. A path costs neither, so the reads happen on the same thread that is
+ * already hashing, with no crossing at all.
+ *
+ * That is what makes the size ceilings stop applying: there is no byte array to count in an
+ * `i32` and nothing resident, so a multi-GB master reads at the disk's speed rather than the
+ * host thread's.
+ *
+ * This is an implementation of the [`RangeSource`] interface, not a way around it: the SDK still
+ * only ever asks for the ranges it needs, and no entry point takes a path.
+ */
+declare class FileSource extends UniffiAbstractObject implements FileSourceLike {
+  readonly [uniffiTypeNameSymbol] = "FileSource";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  private constructor();
+  /**
+   * Open `path` for reading.
+   *
+   * # Errors
+   *
+   * The file does not exist, is not permitted, or cannot be opened.
+   */
+  static open(path: string): FileSourceLike;
+  length(asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<bigint>;
+  readAt(offset: bigint, length: number, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<ArrayBuffer>;
+  uniffiDestroy(): void;
+  static instanceOf(obj_: any): obj_ is FileSource;
+}
+/**
+ * An in-memory [`RangeSource`], for a caller that already holds the whole asset as
+ * bytes and doesn't want to write a custom source. A **native** implementation of a
+ * `with_foreign` interface (`#[uniffi::export]` on the trait impl, not the foreign
+ * callback path), so the generated binding is a plain constructible object and a Python
+ * caller writes no subclass at all: `MemorySource(data)`.
+ *
+ * # Size ceiling
+ *
+ * The asset is resident for the object's lifetime, and the binding counts a byte array in an
+ * `i32`, so a buffer at or above 2 GiB cannot cross the boundary at all. The constructor
+ * rejects one rather than letting a later read come back quietly truncated. Implement
+ * [`RangeSource`] over a file handle for anything approaching that: the SDK only ever asks for
+ * bounded ranges, so nothing else has to hold the asset.
+ *
+ * Construction copies the whole asset across the boundary, on the calling thread: about 5ms for
+ * 10 MB, 315ms for 500 MB. That is the one part of a sign or verify the SDK cannot move off your
+ * thread, and neither a ranged source nor [`FileSource`] pays it.
+ */
+interface MemorySourceLike {
+  length(asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<bigint>;
+  readAt(offset: bigint, length: number, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<ArrayBuffer>;
+}
+/**
+ * @deprecated Use `MemorySourceLike` instead.
+ */
+type MemorySourceInterface = MemorySourceLike;
+/**
+ * An in-memory [`RangeSource`], for a caller that already holds the whole asset as
+ * bytes and doesn't want to write a custom source. A **native** implementation of a
+ * `with_foreign` interface (`#[uniffi::export]` on the trait impl, not the foreign
+ * callback path), so the generated binding is a plain constructible object and a Python
+ * caller writes no subclass at all: `MemorySource(data)`.
+ *
+ * # Size ceiling
+ *
+ * The asset is resident for the object's lifetime, and the binding counts a byte array in an
+ * `i32`, so a buffer at or above 2 GiB cannot cross the boundary at all. The constructor
+ * rejects one rather than letting a later read come back quietly truncated. Implement
+ * [`RangeSource`] over a file handle for anything approaching that: the SDK only ever asks for
+ * bounded ranges, so nothing else has to hold the asset.
+ *
+ * Construction copies the whole asset across the boundary, on the calling thread: about 5ms for
+ * 10 MB, 315ms for 500 MB. That is the one part of a sign or verify the SDK cannot move off your
+ * thread, and neither a ranged source nor [`FileSource`] pays it.
+ */
+declare class MemorySource extends UniffiAbstractObject implements MemorySourceLike {
+  readonly [uniffiTypeNameSymbol] = "MemorySource";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  /**
+   * # Errors
+   *
+   * The buffer is at or above the 2 GiB a byte array can be counted in.
+   */
+  constructor(data: ArrayBuffer);
+  length(asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<bigint>;
+  readAt(offset: bigint, length: number, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<ArrayBuffer>;
+  uniffiDestroy(): void;
+  static instanceOf(obj_: any): obj_ is MemorySource;
+}
+/**
+ * One stream being validated. It owns the session keys and manifest ids its init segments
+ * advertised, so releasing the stream is dropping this object.
+ */
+interface StreamValidationLike {
+  /**
+   * Everything this stream's init segments have registered, as CBOR for another node to
+   * [`resume`](StreamVerifier::resume) from.
+   *
+   * The one piece of stream state that leaves the SDK, and only because a clustered
+   * verifier needs it: the init URL is overwritten on rotation, so a node joining during
+   * the overlap cannot rebuild the previous key by refetching. One value, produced once
+   * and consumed once. Not a store.
+   *
+   * # Errors
+   *
+   * `STREAM_INVALID` when a registered session key cannot be re-encoded.
+   */
+  export_(): ArrayBuffer;
+  /**
+   * Validate any BMFF segment. Classifies internally and dispatches to init- or
+   * media-processing, registering what an init advertises into this handle.
+   *
+   * # Errors
+   *
+   * A `stream.invalid` fault when an init segment is malformed or carries no valid
+   * manifest, or when a media segment arrives before any init was processed for the
+   * stream.
+   */
+  validate(data: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<SegmentValidation>;
+}
+/**
+ * @deprecated Use `StreamValidationLike` instead.
+ */
+type StreamValidationInterface = StreamValidationLike;
+/**
+ * One stream being validated. It owns the session keys and manifest ids its init segments
+ * advertised, so releasing the stream is dropping this object.
+ */
+declare class StreamValidation extends UniffiAbstractObject implements StreamValidationLike {
+  readonly [uniffiTypeNameSymbol] = "StreamValidation";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  private constructor();
+  /**
+   * Everything this stream's init segments have registered, as CBOR for another node to
+   * [`resume`](StreamVerifier::resume) from.
+   *
+   * The one piece of stream state that leaves the SDK, and only because a clustered
+   * verifier needs it: the init URL is overwritten on rotation, so a node joining during
+   * the overlap cannot rebuild the previous key by refetching. One value, produced once
+   * and consumed once. Not a store.
+   *
+   * # Errors
+   *
+   * `STREAM_INVALID` when a registered session key cannot be re-encoded.
+   */
+  export_(): ArrayBuffer;
+  /**
+   * Validate any BMFF segment. Classifies internally and dispatches to init- or
+   * media-processing, registering what an init advertises into this handle.
+   *
+   * # Errors
+   *
+   * A `stream.invalid` fault when an init segment is malformed or carries no valid
+   * manifest, or when a media segment arrives before any init was processed for the
+   * stream.
+   */
+  validate(data: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<SegmentValidation>;
+  uniffiDestroy(): void;
+  static instanceOf(obj_: any): obj_ is StreamValidation;
+}
+/**
+ * A live-stream verifier bound to a trust configuration. Construct once with
+ * [`create`](Self::create), then [`open`](Self::open) a stream to feed segments to.
+ */
+interface StreamVerifierLike {
+  /**
+   * Open `stream_id` for validation, handing back a [`StreamValidation`] to feed
+   * segments to.
+   *
+   * No I/O: the handle carries the id so it cannot be mistyped or confused with another
+   * stream's, and classification still happens per segment. Opening one id twice hands
+   * back the same live session, so a caller that reconnects keeps the state its earlier
+   * handle accumulated.
+   */
+  open(streamId: string): StreamValidationLike;
+  /**
+   * Open `stream_id` on the state another node exported, merged into whatever this one
+   * holds for that id already.
+   *
+   * # Errors
+   *
+   * `STREAM_INVALID` when `state` is not a value [`StreamValidation::export`] produced,
+   * or carries a version this SDK no longer reads.
+   */
+  resume(streamId: string, state: ArrayBuffer): StreamValidationLike;
+}
+/**
+ * @deprecated Use `StreamVerifierLike` instead.
+ */
+type StreamVerifierInterface = StreamVerifierLike;
+/**
+ * A live-stream verifier bound to a trust configuration. Construct once with
+ * [`create`](Self::create), then [`open`](Self::open) a stream to feed segments to.
+ */
+declare class StreamVerifier extends UniffiAbstractObject implements StreamVerifierLike {
+  readonly [uniffiTypeNameSymbol] = "StreamVerifier";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  private constructor();
+  /**
+   * Build a stream verifier from [`StreamVerifierOptions`].
+   *
+   * # Errors
+   *
+   * `TRUST_CONFIG_INVALID` when the trust anchors can't be parsed.
+   */
+  static create(options: StreamVerifierOptions): StreamVerifierLike;
+  /**
+   * Open `stream_id` for validation, handing back a [`StreamValidation`] to feed
+   * segments to.
+   *
+   * No I/O: the handle carries the id so it cannot be mistyped or confused with another
+   * stream's, and classification still happens per segment. Opening one id twice hands
+   * back the same live session, so a caller that reconnects keeps the state its earlier
+   * handle accumulated.
+   */
+  open(streamId: string): StreamValidationLike;
+  /**
+   * Open `stream_id` on the state another node exported, merged into whatever this one
+   * holds for that id already.
+   *
+   * # Errors
+   *
+   * `STREAM_INVALID` when `state` is not a value [`StreamValidation::export`] produced,
+   * or carries a version this SDK no longer reads.
+   */
+  resume(streamId: string, state: ArrayBuffer): StreamValidationLike;
+  uniffiDestroy(): void;
+  static instanceOf(obj_: any): obj_ is StreamVerifier;
+}
+/**
+ * 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.
+ */
+declare function uniffiEnsureInitialized(): void;
+declare const _default$1: Readonly<{
+  initialize: typeof uniffiEnsureInitialized;
+  converters: {
+    FfiConverterTypeActor: {
+      readFromCursor(c: Cursor): Actor;
+      writeIntoCursor(value: Actor, c: Cursor): void;
+      allocationSize(value: Actor): number;
+      lift(value: UniffiByteArray): Actor;
+      lower(value: Actor, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeAssertionMetadata: {
+      readFromCursor(c: Cursor): AssertionMetadata;
+      writeIntoCursor(value: AssertionMetadata, c: Cursor): void;
+      allocationSize(value: AssertionMetadata): number;
+      lift(value: UniffiByteArray): AssertionMetadata;
+      lower(value: AssertionMetadata, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeAssetType: {
+      readFromCursor(c: Cursor): AssetType;
+      writeIntoCursor(value: AssetType, c: Cursor): void;
+      allocationSize(value: AssetType): number;
+      lift(value: UniffiByteArray): AssetType;
+      lower(value: AssetType, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeAssetVerification: {
+      readFromCursor(c: Cursor): AssetVerification;
+      writeIntoCursor(value: AssetVerification, c: Cursor): void;
+      allocationSize(value: AssetVerification): number;
+      lift(value: UniffiByteArray): AssetVerification;
+      lower(value: AssetVerification, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeAssetVerifier: FfiConverterObject<AssetVerifierLike>;
+    FfiConverterTypeAssetVerifierOptions: {
+      readFromCursor(c: Cursor): AssetVerifierOptions;
+      writeIntoCursor(value: AssetVerifierOptions, c: Cursor): void;
+      allocationSize(value: AssetVerifierOptions): number;
+      lift(value: UniffiByteArray): AssetVerifierOptions;
+      lower(value: AssetVerifierOptions, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeBinder: FfiConverterObject<BinderLike>;
+    FfiConverterTypeClaimGeneratorInfo: {
+      readFromCursor(c: Cursor): ClaimGeneratorInfo;
+      writeIntoCursor(value: ClaimGeneratorInfo, c: Cursor): void;
+      allocationSize(value: ClaimGeneratorInfo): number;
+      lift(value: UniffiByteArray): ClaimGeneratorInfo;
+      lower(value: ClaimGeneratorInfo, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeCode: {
+      readFromCursor(c: Cursor): Code;
+      writeIntoCursor(value: Code, c: Cursor): void;
+      allocationSize(value: Code): number;
+      lift(value: UniffiByteArray): Code;
+      lower(value: Code, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeContentBindingClass: {
+      readFromCursor(c: Cursor): ContentBindingClass;
+      writeIntoCursor(value: ContentBindingClass, c: Cursor): void;
+      allocationSize(value: ContentBindingClass): number;
+      lift(value: UniffiByteArray): ContentBindingClass;
+      lower(value: ContentBindingClass, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeContentBindingEvidence: {
+      readFromCursor(c: Cursor): ContentBindingEvidence;
+      writeIntoCursor(value: ContentBindingEvidence, c: Cursor): void;
+      allocationSize(value: ContentBindingEvidence): number;
+      lift(value: UniffiByteArray): ContentBindingEvidence;
+      lower(value: ContentBindingEvidence, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeCoordinate: {
+      readFromCursor(c: Cursor): Coordinate;
+      writeIntoCursor(value: Coordinate, c: Cursor): void;
+      allocationSize(value: Coordinate): number;
+      lift(value: UniffiByteArray): Coordinate;
+      lower(value: Coordinate, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeCredentialOrigin: {
+      readFromCursor(c: Cursor): CredentialOrigin;
+      writeIntoCursor(value: CredentialOrigin, c: Cursor): void;
+      allocationSize(value: CredentialOrigin): number;
+      lift(value: UniffiByteArray): CredentialOrigin;
+      lower(value: CredentialOrigin, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeDataSource: {
+      readFromCursor(c: Cursor): DataSource;
+      writeIntoCursor(value: DataSource, c: Cursor): void;
+      allocationSize(value: DataSource): number;
+      lift(value: UniffiByteArray): DataSource;
+      lower(value: DataSource, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeDeriveOptions: {
+      readFromCursor(c: Cursor): DeriveOptions;
+      writeIntoCursor(value: DeriveOptions, c: Cursor): void;
+      allocationSize(value: DeriveOptions): number;
+      lift(value: UniffiByteArray): DeriveOptions;
+      lower(value: DeriveOptions, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeEndInclusivity: {
+      readFromCursor(c: Cursor): EndInclusivity;
+      writeIntoCursor(value: EndInclusivity, c: Cursor): void;
+      allocationSize(value: EndInclusivity): number;
+      lift(value: UniffiByteArray): EndInclusivity;
+      lower(value: EndInclusivity, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeFieldViolation: {
+      readFromCursor(c: Cursor): FieldViolation;
+      writeIntoCursor(value: FieldViolation, c: Cursor): void;
+      allocationSize(value: FieldViolation): number;
+      lift(value: UniffiByteArray): FieldViolation;
+      lower(value: FieldViolation, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeFileSource: FfiConverterObject<FileSourceLike>;
+    FfiConverterTypeFingerprintCheck: {
+      readFromCursor(c: Cursor): FingerprintCheck;
+      writeIntoCursor(value: FingerprintCheck, c: Cursor): void;
+      allocationSize(value: FingerprintCheck): number;
+      lift(value: UniffiByteArray): FingerprintCheck;
+      lower(value: FingerprintCheck, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeFoundCredential: {
+      readFromCursor(c: Cursor): FoundCredential;
+      writeIntoCursor(value: FoundCredential, c: Cursor): void;
+      allocationSize(value: FoundCredential): number;
+      lift(value: UniffiByteArray): FoundCredential;
+      lower(value: FoundCredential, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeFrame: {
+      readFromCursor(c: Cursor): Frame;
+      writeIntoCursor(value: Frame, c: Cursor): void;
+      allocationSize(value: Frame): number;
+      lift(value: UniffiByteArray): Frame;
+      lower(value: Frame, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeGoldenComparison: {
+      readFromCursor(c: Cursor): GoldenComparison;
+      writeIntoCursor(value: GoldenComparison, c: Cursor): void;
+      allocationSize(value: GoldenComparison): number;
+      lift(value: UniffiByteArray): GoldenComparison;
+      lower(value: GoldenComparison, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeHashedUri: {
+      readFromCursor(c: Cursor): HashedUri;
+      writeIntoCursor(value: HashedUri, c: Cursor): void;
+      allocationSize(value: HashedUri): number;
+      lift(value: UniffiByteArray): HashedUri;
+      lower(value: HashedUri, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeIngredient: {
+      readFromCursor(c: Cursor): Ingredient;
+      writeIntoCursor(value: Ingredient, c: Cursor): void;
+      allocationSize(value: Ingredient): number;
+      lift(value: UniffiByteArray): Ingredient;
+      lower(value: Ingredient, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeIngredientDeltaValidationResult: {
+      readFromCursor(c: Cursor): IngredientDeltaValidationResult;
+      writeIntoCursor(value: IngredientDeltaValidationResult, c: Cursor): void;
+      allocationSize(value: IngredientDeltaValidationResult): number;
+      lift(value: UniffiByteArray): IngredientDeltaValidationResult;
+      lower(value: IngredientDeltaValidationResult, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeInitValidation: {
+      readFromCursor(c: Cursor): InitValidation;
+      writeIntoCursor(value: InitValidation, c: Cursor): void;
+      allocationSize(value: InitValidation): number;
+      lift(value: UniffiByteArray): InitValidation;
+      lower(value: InitValidation, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeItem: {
+      readFromCursor(c: Cursor): Item;
+      writeIntoCursor(value: Item, c: Cursor): void;
+      allocationSize(value: Item): number;
+      lift(value: UniffiByteArray): Item;
+      lower(value: Item, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeManifest: {
+      readFromCursor(c: Cursor): Manifest;
+      writeIntoCursor(value: Manifest, c: Cursor): void;
+      allocationSize(value: Manifest): number;
+      lift(value: UniffiByteArray): Manifest;
+      lower(value: Manifest, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeManifestAssertion: {
+      readFromCursor(c: Cursor): ManifestAssertion;
+      writeIntoCursor(value: ManifestAssertion, c: Cursor): void;
+      allocationSize(value: ManifestAssertion): number;
+      lift(value: UniffiByteArray): ManifestAssertion;
+      lower(value: ManifestAssertion, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeManifestAssertionKind: {
+      readFromCursor(c: Cursor): ManifestAssertionKind;
+      writeIntoCursor(value: ManifestAssertionKind, c: Cursor): void;
+      allocationSize(value: ManifestAssertionKind): number;
+      lift(value: UniffiByteArray): ManifestAssertionKind;
+      lower(value: ManifestAssertionKind, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeManifestStore: {
+      readFromCursor(c: Cursor): ManifestStore;
+      writeIntoCursor(value: ManifestStore, c: Cursor): void;
+      allocationSize(value: ManifestStore): number;
+      lift(value: UniffiByteArray): ManifestStore;
+      lower(value: ManifestStore, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeMediaValidation: {
+      readFromCursor(c: Cursor): MediaValidation;
+      writeIntoCursor(value: MediaValidation, c: Cursor): void;
+      allocationSize(value: MediaValidation): number;
+      lift(value: UniffiByteArray): MediaValidation;
+      lower(value: MediaValidation, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeMemorySource: FfiConverterObject<MemorySourceLike>;
+    FfiConverterTypePluginRegistry: FfiConverterObject<PluginRegistryLike>;
+    FfiConverterTypeRange: {
+      readFromCursor(c: Cursor): Range;
+      writeIntoCursor(value: Range, c: Cursor): void;
+      allocationSize(value: Range): number;
+      lift(value: UniffiByteArray): Range;
+      lower(value: Range, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRangeSource: FfiConverterObjectWithCallbacks<RangeSource>;
+    FfiConverterTypeRangeType: {
+      readFromCursor(c: Cursor): RangeType;
+      writeIntoCursor(value: RangeType, c: Cursor): void;
+      allocationSize(value: RangeType): number;
+      lift(value: UniffiByteArray): RangeType;
+      lower(value: RangeType, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRecoveryIssue: {
+      readFromCursor(c: Cursor): RecoveryIssue;
+      writeIntoCursor(value: RecoveryIssue, c: Cursor): void;
+      allocationSize(value: RecoveryIssue): number;
+      lift(value: UniffiByteArray): RecoveryIssue;
+      lower(value: RecoveryIssue, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRecoveryIssueKind: {
+      readFromCursor(c: Cursor): RecoveryIssueKind;
+      writeIntoCursor(value: RecoveryIssueKind, c: Cursor): void;
+      allocationSize(value: RecoveryIssueKind): number;
+      lift(value: UniffiByteArray): RecoveryIssueKind;
+      lower(value: RecoveryIssueKind, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRecoveryPolicy: {
+      readFromCursor(c: Cursor): RecoveryPolicy;
+      writeIntoCursor(value: RecoveryPolicy, c: Cursor): void;
+      allocationSize(value: RecoveryPolicy): number;
+      lift(value: UniffiByteArray): RecoveryPolicy;
+      lower(value: RecoveryPolicy, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRecoveryStatus: {
+      readFromCursor(c: Cursor): RecoveryStatus;
+      writeIntoCursor(value: RecoveryStatus, c: Cursor): void;
+      allocationSize(value: RecoveryStatus): number;
+      lift(value: UniffiByteArray): RecoveryStatus;
+      lower(value: RecoveryStatus, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRecoverySummary: {
+      readFromCursor(c: Cursor): RecoverySummary;
+      writeIntoCursor(value: RecoverySummary, c: Cursor): void;
+      allocationSize(value: RecoverySummary): number;
+      lift(value: UniffiByteArray): RecoverySummary;
+      lower(value: RecoverySummary, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRegion: {
+      readFromCursor(c: Cursor): Region;
+      writeIntoCursor(value: Region, c: Cursor): void;
+      allocationSize(value: Region): number;
+      lift(value: UniffiByteArray): Region;
+      lower(value: Region, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRegionOfInterest: {
+      readFromCursor(c: Cursor): RegionOfInterest;
+      writeIntoCursor(value: RegionOfInterest, c: Cursor): void;
+      allocationSize(value: RegionOfInterest): number;
+      lift(value: UniffiByteArray): RegionOfInterest;
+      lower(value: RegionOfInterest, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRegistryOptions: {
+      readFromCursor(c: Cursor): RegistryOptions;
+      writeIntoCursor(value: RegistryOptions, c: Cursor): void;
+      allocationSize(value: RegistryOptions): number;
+      lift(value: UniffiByteArray): RegistryOptions;
+      lower(value: RegistryOptions, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRegistryQueries: {
+      readFromCursor(c: Cursor): RegistryQueries;
+      writeIntoCursor(value: RegistryQueries, c: Cursor): void;
+      allocationSize(value: RegistryQueries): number;
+      lift(value: UniffiByteArray): RegistryQueries;
+      lower(value: RegistryQueries, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRelationship: {
+      readFromCursor(c: Cursor): Relationship;
+      writeIntoCursor(value: Relationship, c: Cursor): void;
+      allocationSize(value: Relationship): number;
+      lift(value: UniffiByteArray): Relationship;
+      lower(value: Relationship, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeResourceRef: {
+      readFromCursor(c: Cursor): ResourceRef;
+      writeIntoCursor(value: ResourceRef, c: Cursor): void;
+      allocationSize(value: ResourceRef): number;
+      lift(value: UniffiByteArray): ResourceRef;
+      lower(value: ResourceRef, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeReviewRating: {
+      readFromCursor(c: Cursor): ReviewRating;
+      writeIntoCursor(value: ReviewRating, c: Cursor): void;
+      allocationSize(value: ReviewRating): number;
+      lift(value: UniffiByteArray): ReviewRating;
+      lower(value: ReviewRating, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeRole: {
+      readFromCursor(c: Cursor): Role;
+      writeIntoCursor(value: Role, c: Cursor): void;
+      allocationSize(value: Role): number;
+      lift(value: UniffiByteArray): Role;
+      lower(value: Role, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeSdkError: {
+      readFromCursor(c: Cursor): SdkError;
+      writeIntoCursor(value: SdkError, c: Cursor): void;
+      allocationSize(value: SdkError): number;
+      lift(value: UniffiByteArray): SdkError;
+      lower(value: SdkError, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeSegmentTiming: {
+      readFromCursor(c: Cursor): SegmentTiming;
+      writeIntoCursor(value: SegmentTiming, c: Cursor): void;
+      allocationSize(value: SegmentTiming): number;
+      lift(value: UniffiByteArray): SegmentTiming;
+      lower(value: SegmentTiming, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeSegmentValidation: {
+      readFromCursor(c: Cursor): SegmentValidation;
+      writeIntoCursor(value: SegmentValidation, c: Cursor): void;
+      allocationSize(value: SegmentValidation): number;
+      lift(value: UniffiByteArray): SegmentValidation;
+      lower(value: SegmentValidation, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeSessionKeySummary: {
+      readFromCursor(c: Cursor): SessionKeySummary;
+      writeIntoCursor(value: SessionKeySummary, c: Cursor): void;
+      allocationSize(value: SessionKeySummary): number;
+      lift(value: UniffiByteArray): SessionKeySummary;
+      lower(value: SessionKeySummary, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeShape: {
+      readFromCursor(c: Cursor): Shape;
+      writeIntoCursor(value: Shape, c: Cursor): void;
+      allocationSize(value: Shape): number;
+      lift(value: UniffiByteArray): Shape;
+      lower(value: Shape, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeShapeType: {
+      readFromCursor(c: Cursor): ShapeType;
+      writeIntoCursor(value: ShapeType, c: Cursor): void;
+      allocationSize(value: ShapeType): number;
+      lift(value: UniffiByteArray): ShapeType;
+      lower(value: ShapeType, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeSignatureInfo: {
+      readFromCursor(c: Cursor): SignatureInfo;
+      writeIntoCursor(value: SignatureInfo, c: Cursor): void;
+      allocationSize(value: SignatureInfo): number;
+      lift(value: UniffiByteArray): SignatureInfo;
+      lower(value: SignatureInfo, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeSigningAlgSchema: {
+      readFromCursor(c: Cursor): SigningAlgSchema;
+      writeIntoCursor(value: SigningAlgSchema, c: Cursor): void;
+      allocationSize(value: SigningAlgSchema): number;
+      lift(value: UniffiByteArray): SigningAlgSchema;
+      lower(value: SigningAlgSchema, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeSimilarityScore: FfiConverter<number, number>;
+    FfiConverterTypeSoftBinding: {
+      readFromCursor(c: Cursor): SoftBinding;
+      writeIntoCursor(value: SoftBinding, c: Cursor): void;
+      allocationSize(value: SoftBinding): number;
+      lift(value: UniffiByteArray): SoftBinding;
+      lower(value: SoftBinding, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeStatusCodes: {
+      readFromCursor(c: Cursor): StatusCodes;
+      writeIntoCursor(value: StatusCodes, c: Cursor): void;
+      allocationSize(value: StatusCodes): number;
+      lift(value: UniffiByteArray): StatusCodes;
+      lower(value: StatusCodes, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeStreamValidation: FfiConverterObject<StreamValidationLike>;
+    FfiConverterTypeStreamVerifier: FfiConverterObject<StreamVerifierLike>;
+    FfiConverterTypeStreamVerifierOptions: {
+      readFromCursor(c: Cursor): StreamVerifierOptions;
+      writeIntoCursor(value: StreamVerifierOptions, c: Cursor): void;
+      allocationSize(value: StreamVerifierOptions): number;
+      lift(value: UniffiByteArray): StreamVerifierOptions;
+      lower(value: StreamVerifierOptions, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeText: {
+      readFromCursor(c: Cursor): Text;
+      writeIntoCursor(value: Text, c: Cursor): void;
+      allocationSize(value: Text): number;
+      lift(value: UniffiByteArray): Text;
+      lower(value: Text, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeTextSelector: {
+      readFromCursor(c: Cursor): TextSelector;
+      writeIntoCursor(value: TextSelector, c: Cursor): void;
+      allocationSize(value: TextSelector): number;
+      lift(value: UniffiByteArray): TextSelector;
+      lower(value: TextSelector, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeTextSelectorRange: {
+      readFromCursor(c: Cursor): TextSelectorRange;
+      writeIntoCursor(value: TextSelectorRange, c: Cursor): void;
+      allocationSize(value: TextSelectorRange): number;
+      lift(value: UniffiByteArray): TextSelectorRange;
+      lower(value: TextSelectorRange, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeTime: {
+      readFromCursor(c: Cursor): Time;
+      writeIntoCursor(value: Time, c: Cursor): void;
+      allocationSize(value: Time): number;
+      lift(value: UniffiByteArray): Time;
+      lower(value: Time, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeTimeType: {
+      readFromCursor(c: Cursor): TimeType;
+      writeIntoCursor(value: TimeType, c: Cursor): void;
+      allocationSize(value: TimeType): number;
+      lift(value: UniffiByteArray): TimeType;
+      lower(value: TimeType, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeUnitType: {
+      readFromCursor(c: Cursor): UnitType;
+      writeIntoCursor(value: UnitType, c: Cursor): void;
+      allocationSize(value: UnitType): number;
+      lift(value: UniffiByteArray): UnitType;
+      lower(value: UnitType, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeUriOrResource: {
+      readFromCursor(c: Cursor): UriOrResource;
+      writeIntoCursor(value: UriOrResource, c: Cursor): void;
+      allocationSize(value: UriOrResource): number;
+      lift(value: UniffiByteArray): UriOrResource;
+      lower(value: UriOrResource, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeValidationCode: {
+      readFromCursor(c: Cursor): ValidationCode;
+      writeIntoCursor(value: ValidationCode, c: Cursor): void;
+      allocationSize(value: ValidationCode): number;
+      lift(value: UniffiByteArray): ValidationCode;
+      lower(value: ValidationCode, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeValidationCodeKind: {
+      readFromCursor(c: Cursor): ValidationCodeKind;
+      writeIntoCursor(value: ValidationCodeKind, c: Cursor): void;
+      allocationSize(value: ValidationCodeKind): number;
+      lift(value: UniffiByteArray): ValidationCodeKind;
+      lower(value: ValidationCodeKind, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeValidationResults: {
+      readFromCursor(c: Cursor): ValidationResults;
+      writeIntoCursor(value: ValidationResults, c: Cursor): void;
+      allocationSize(value: ValidationResults): number;
+      lift(value: UniffiByteArray): ValidationResults;
+      lower(value: ValidationResults, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeValidationState: {
+      readFromCursor(c: Cursor): ValidationState;
+      writeIntoCursor(value: ValidationState, c: Cursor): void;
+      allocationSize(value: ValidationState): number;
+      lift(value: UniffiByteArray): ValidationState;
+      lower(value: ValidationState, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeValidationStatus: {
+      readFromCursor(c: Cursor): ValidationStatus;
+      writeIntoCursor(value: ValidationStatus, c: Cursor): void;
+      allocationSize(value: ValidationStatus): number;
+      lift(value: UniffiByteArray): ValidationStatus;
+      lower(value: ValidationStatus, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeValue: FfiConverter<UniffiByteArray, string>;
+    FfiConverterTypeVerifyOptions: {
+      readFromCursor(c: Cursor): VerifyOptions;
+      writeIntoCursor(value: VerifyOptions, c: Cursor): void;
+      allocationSize(value: VerifyOptions): number;
+      lift(value: UniffiByteArray): VerifyOptions;
+      lower(value: VerifyOptions, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+  };
+}>;
+//#endregion
+//#region ../../../../target/trylimbo/codegen/ffi-trylimbo_sdk_verifier/index.d.ts
+declare function uniffiInitAsync(): Promise<void>;
+declare const _default: {
+  trylimbo_verifier: typeof trylimbo_verifier_d_exports;
+};
+//#endregion
+export { Actor, AssertionMetadata, AssetType, AssetVerification, AssetVerifier, AssetVerifierInterface, AssetVerifierLike, AssetVerifierOptions, Binder, BinderInterface, BinderLike, ClaimGeneratorInfo, Code, ContentBindingClass, ContentBindingEvidence, Coordinate, CredentialOrigin, CredentialOrigin_Tags, DataSource, DeriveOptions, EndInclusivity, FieldViolation, FileSource, FileSourceInterface, FileSourceLike, FingerprintCheck, FingerprintCheck_Tags, FoundCredential, Frame, GoldenComparison, GoldenComparison_Tags, HashedUri, Ingredient, IngredientDeltaValidationResult, InitValidation, Item, Manifest, ManifestAssertion, ManifestAssertionKind, ManifestStore, MediaValidation, MemorySource, MemorySourceInterface, MemorySourceLike, PluginRead, PluginRegistry, PluginRegistryInterface, PluginRegistryLike, Range, RangeSource, RangeSourceImpl, RangeType, RecoveryIssue, RecoveryIssueKind, RecoveryPolicy, RecoveryStatus, RecoverySummary, Region, RegionOfInterest, RegistryOptions, RegistryQueries, Relationship, ResourceRef, ReviewRating, Role, SdkError, SdkError_Tags, SegmentTiming, SegmentValidation, SegmentValidation_Tags, SessionKeySummary, Shape, ShapeType, SignatureInfo, SigningAlgSchema, SimilarityScore, SoftBinding, StatusCodes, StreamValidation, StreamValidationInterface, StreamValidationLike, StreamVerifier, StreamVerifierInterface, StreamVerifierLike, StreamVerifierOptions, Text, TextSelector, TextSelectorRange, Time, TimeType, UnitType, UriOrResource, UriOrResource_Tags, ValidationCode, ValidationCodeKind, ValidationResults, ValidationState, ValidationStatus, Value, VerifyOptions, c2paTrustList, c2paTsaTrustList, _default as default, devCa, parse, resource, thumbnails, uniffiInitAsync };