@trylimbo/sdk-verifier-wasm 0.1.0-canary.100

package/gen/wasm/trylimbo_sdk_verifier.d.ts

@@ -0,0 +1,704 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * The `ReadableStreamType` enum.
+ *
+ * *This API requires the following crate features to be activated: `ReadableStreamType`*
+ */
+
+export type ReadableStreamType = "bytes";
+
+/** Sync ranged reader for Node.js (backed by `fs.readSync`). */
+export interface RangeSource {
+    length: number;
+    readAt: (offset: number, length: number) => Uint8Array;
+}
+
+
+/**
+ * A C2PA soft binding: an algorithm id (from the C2PA soft-binding algorithm
+ * list, e.g. `io.iscc.v0`) plus its algorithm-specific value (the `ISCC:…` code,
+ * a watermark token, …). The signer embeds it as a `c2pa.soft-binding` assertion
+ * and indexes it, so a transcoded copy whose exact content hash no longer
+ * matches still recovers the manifest from the registry.
+ */
+export interface SoftBinding {
+    /**
+     * C2PA soft-binding algorithm id, e.g. `io.iscc.v0`.
+     */
+    alg: string;
+    /**
+     * Algorithm-specific binding value: the canonical string the algorithm
+     * produces (an `ISCC:…` code, a watermark token). Its UTF-8 bytes are what
+     * the registry lookup base64-encodes.
+     */
+    value: string;
+}
+
+/**
+ * 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.
+ */
+export type Code = "canceled" | "unknown" | "invalid_argument" | "deadline_exceeded" | "not_found" | "already_exists" | "permission_denied" | "resource_exhausted" | "failed_precondition" | "aborted" | "out_of_range" | "unimplemented" | "internal" | "unavailable" | "data_loss" | "unauthenticated";
+
+/**
+ * A request-validation fault, `google.rpc.BadRequest` (`kind: \"invalid\"`).
+ */
+export interface InvalidError {
+    code: Code;
+    message: string;
+    fieldViolations: FieldViolation[];
+}
+
+/**
+ * A semantic fault carrying a `google.rpc.ErrorInfo` reason (`kind: \"reason\"`).
+ *
+ * `hashmap_as_object` restates what [`SdkError`] already sets: a container\'s `.d.ts` is
+ * generated from its own config, so without it `metadata` is declared `Map<string, string>`
+ * for a value the ABI never emits as a `Map`.
+ */
+export interface ReasonError {
+    code: Code;
+    message: string;
+    reason: string;
+    domain: string;
+    metadata: Record<string, string>;
+}
+
+/**
+ * A session signing key from the init manifest\'s roster (spec §19.4.4).
+ */
+export interface SessionKeySummary {
+    /**
+     * Identifier of the session signing key.
+     */
+    keyId: Uint8Array;
+    /**
+     * The session key\'s public half (SEC1-encoded bytes).
+     */
+    publicKey: Uint8Array;
+}
+
+/**
+ * A status with no structured detail (`kind: \"status\"`).
+ */
+export interface StatusError {
+    code: Code;
+    message: string;
+}
+
+/**
+ * C2PA validation state of a manifest (spec §14.3).
+ */
+export type ValidationState = "Invalid" | "Valid" | "Trusted";
+
+/**
+ * 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.
+ */
+export interface 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: 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?: string[];
+}
+
+/**
+ * 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.
+ */
+export interface StreamVerifierOptions {
+    /**
+     * PEM trust anchors for the caller\'s own issuers.
+     */
+    trustAnchors: 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?: 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?: number;
+}
+
+/**
+ * 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.
+ */
+export type RegistryQueries = "derived" | "derivedThenContent";
+
+/**
+ * One C2PA validation status entry (spec §15.3).
+ */
+export interface ValidationCode {
+    /**
+     * C2PA validation status string (e.g. `signingCredential.trusted`).
+     */
+    code: string;
+    kind: ValidationCodeKind;
+}
+
+/**
+ * One `google.rpc.BadRequest.FieldViolation`.
+ */
+export interface FieldViolation {
+    field: string;
+    description: string;
+    reason: string;
+}
+
+/**
+ * One `verify` credential: the c2pa `ManifestStore`, where it came from, and whether the
+ * asset\'s own fingerprint backs it up.
+ */
+export interface 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: Record<string, Uint8Array>;
+    /**
+     * Where this credential came from. See [`CredentialOrigin`].
+     */
+    origin: CredentialOrigin;
+    manifest: import('@contentauth/c2pa-types').ManifestStore;
+    /**
+     * Whether the asset\'s own fingerprint backs up a mark that led here (C2PA 2.4 1.2.2.3).
+     */
+    fingerprintCheck: FingerprintCheck;
+}
+
+/**
+ * Outcome of validating a media segment against its stream\'s init.
+ */
+export interface MediaValidation {
+    valid: boolean;
+    codes: ValidationCode[];
+    keyId: Uint8Array;
+    timing: SegmentTiming;
+    manifestId: string;
+}
+
+/**
+ * Outcome of validating a stream\'s init segment.
+ */
+export interface InitValidation {
+    state: ValidationState;
+    codes: ValidationCode[];
+    manifest: import('@contentauth/c2pa-types').ManifestStore;
+    sessionKeys: SessionKeySummary[];
+}
+
+/**
+ * Result of `StreamValidation.validate`, discriminated by `kind`.
+ */
+export type SegmentValidation = ({ kind: "init" } & InitValidation) | ({ kind: "media" } & MediaValidation) | { kind: "unknown" };
+
+/**
+ * The error every SDK call throws: a decoded `google.rpc.Status`, discriminated
+ * by `kind`. A consumer switches on `err.kind` (`\"reason\" | \"invalid\" | \"status\"`)
+ * and reads the shape-specific fields; `code` and `message` are common to every
+ * shape. Thrown as a plain object across the wasm boundary (tsify).
+ */
+export type SdkError = ({ kind: "status" } & StatusError) | ({ kind: "reason" } & ReasonError) | ({ kind: "invalid" } & InvalidError);
+
+/**
+ * Timing facts carried by a media segment\'s container.
+ */
+export interface SegmentTiming {
+    /**
+     * Media segment sequence number (exact below 2^53).
+     */
+    sequenceNumber: number;
+    /**
+     * 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;
+}
+
+/**
+ * When [`AssetVerifier::verify_asset`] queries the registry.
+ */
+export type RecoveryPolicy = "whenMissing" | "always";
+
+/**
+ * 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.
+ */
+export interface 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;
+}
+
+/**
+ * Whether a code is a success, an informational note, or a failure.
+ */
+export type ValidationCodeKind = "success" | "informational" | "failure";
+
+/**
+ * [`crate::asset::CredentialOrigin`] as JS sees it: a tagged union, since each way of finding a
+ * credential carries different evidence. Lane-local for the same reason [`FingerprintCheck`] is: a
+ * tag layout is what `#[binding(wasm)]` declines to express.
+ */
+export type CredentialOrigin = { kind: "embedded" } | { kind: "recoveredByFingerprint"; binding: SoftBinding; registryScore: number | undefined } | { kind: "recoveredByWatermark"; binding: SoftBinding; registryScore: number | undefined } | { kind: "recoveredByContent"; discoveries: ContentBindingEvidence[] };
+
+/**
+ * [`crate::asset::FingerprintCheck`] as JS sees it: a tagged union, since `compared` carries a
+ * measurement the other two do not. Lane-local rather than `#[binding(wasm)]` on the core,
+ * because a tag layout is exactly what that macro declines to express.
+ */
+export type FingerprintCheck = { kind: "notNeeded" } | { kind: "nothingToCompare" } | { kind: "unsupported"; algorithm: string } | { kind: "indeterminate" } | { kind: "compared"; score: number };
+
+export interface AssetVerification {
+    credentials: FoundCredential[];
+    recovery: RecoverySummary;
+    goldenComparison: GoldenComparison;
+}
+
+export interface ContentBindingEvidence {
+    algorithm: string;
+    class: ContentBindingClass;
+    hint: SoftBinding | undefined;
+    registryScore: number | undefined;
+}
+
+export interface RecoveryIssue {
+    kind: RecoveryIssueKind;
+    manifestId: string | undefined;
+    message: string;
+}
+
+export interface RecoverySummary {
+    status: RecoveryStatus;
+    bestCredentialIndex: number | undefined;
+    issues: RecoveryIssue[];
+}
+
+export type ContentBindingClass = "fingerprint" | "watermark";
+
+export type GoldenComparison = { kind: "notRequested" } | { kind: "noEmbeddedManifest" } | { kind: "noRecoveredManifest" } | { kind: "matches"; recoveredIndex: number } | { kind: "differs"; recoveredIndex: number } | { kind: "indeterminate"; recoveredIndex: number | undefined };
+
+export type RecoveryIssueKind = "binder" | "bindingQuery" | "queryRefused" | "contentQuery" | "capabilities" | "contentTooLarge" | "candidateFetch" | "candidateValidation" | "resourceLimit";
+
+export type RecoveryStatus = "notRequested" | "notFound" | "recovered" | "incomplete";
+
+
+export class AssetVerifier {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * # Errors
+     *
+     * Throws `TRUST_CONFIG_INVALID` when the trust anchors are invalid.
+     */
+    static create(options: AssetVerifierOptions): AssetVerifier;
+    /**
+     * Verify an asset against the configured trust anchors. `binders` compose
+     * soft-binding recovery after the embedded pass, tried in order,
+     * first hit wins; pass `[]` to proceed directly to registry `byContent` recovery.
+     *
+     * Reads the C2PA-native formats. A container format (MXF) is plugin-backed, and plugins
+     * are native, so a master is verified through the native SDK.
+     *
+     * # Errors
+     *
+     * Throws on a malformed `input`, a registry (or binder) failure, or a validation
+     * failure.
+     */
+    verify(input: RangeSource, binders: Binder[]): Promise<AssetVerification>;
+}
+
+/**
+ * A soft-binding binder a client runs itself. Build with `Binder.iscc()` or
+ * `Binder.held(binding)`, and pass a list to `verify`.
+ *
+ * Vendor watermark detection is registry-side in this SDK: configured detectors participate in
+ * `verify` through `byContent`, while `Binder.held` covers values already available to the caller.
+ */
+export class Binder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Derive this binder's binding standalone; `undefined` when it finds none.
+     * Input is a `RangeSource` (format inferred from content when omitted).
+     *
+     * # Errors
+     *
+     * Throws on malformed or unreadable input.
+     */
+    derive(content: RangeSource, format?: string | null): Promise<SoftBinding | undefined>;
+    /**
+     * A binder contributing a binding you already hold (e.g. an out-of-band video ISCC).
+     */
+    static held(binding: SoftBinding): Binder;
+    /**
+     * Local ISCC Image-Code for supported image formats.
+     */
+    static iscc(): Binder;
+}
+
+/**
+ * A [`RangeSource`](crate::wasm::RangeInput) over a `Blob`: a `File` off an `<input>`, a
+ * `Response.blob()`, a handle from the file system access API.
+ *
+ * The only source here that holds nothing. The SDK reads one slice at a time, so an asset larger
+ * than the tab's memory verifies at the disk's speed rather than the heap's, and neither ceiling
+ * the other two carry applies.
+ *
+ * # Worker only
+ *
+ * A `Blob` has exactly one synchronous read, `FileReaderSync`, and it is defined on workers alone.
+ * Constructing this on a document's own thread throws. That is the platform's constraint rather
+ * than the SDK's, and it is reported at construction rather than at the first read.
+ */
+export class BlobSource {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * # Errors
+     *
+     * Throws when this is not a worker thread, where a `Blob` cannot be read synchronously.
+     */
+    constructor(blob: Blob);
+    /**
+     * Answers the platform's own array, never routed through linear memory: the port's JS-facing
+     * half exists so this hop costs one copy rather than three.
+     *
+     * # Errors
+     *
+     * Throws when the platform refuses the slice or the read. Reading at or past the end is not a
+     * failure: it answers empty, which every caller already reads as an end of file.
+     */
+    readAt(offset: number, length: number): Uint8Array;
+    /**
+     * The offset is a JS number rather than a `u32` because a `Blob` is the one store here that
+     * can outrun what a `u32` names, and it is the width the platform's own slice takes.
+     */
+    readonly length: number;
+}
+
+/**
+ * A [`RangeSource`](crate::wasm::RangeInput) over bytes the caller already holds, read in place.
+ *
+ * [`MemorySource`] without the copy: the array stays on the JS side and only the window the SDK
+ * asks for crosses, so nothing is resident here and linear memory's 4 GiB ceiling never applies to
+ * the asset.
+ */
+export class BytesSource {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(data: Uint8Array);
+    readAt(offset: number, length: number): Uint8Array;
+    readonly length: number;
+}
+
+export function C2PA_TRUST_LIST(): string;
+
+export function C2PA_TSA_TRUST_LIST(): string;
+
+export function DEV_CA(): string;
+
+export class IntoUnderlyingByteSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableByteStreamController): Promise<any>;
+    start(controller: ReadableByteStreamController): void;
+    readonly autoAllocateChunkSize: number;
+    readonly type: ReadableStreamType;
+}
+
+export class IntoUnderlyingSink {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    abort(reason: any): Promise<any>;
+    close(): Promise<any>;
+    write(chunk: any): Promise<any>;
+}
+
+export class IntoUnderlyingSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableStreamDefaultController): Promise<any>;
+}
+
+/**
+ * An in-memory [`RangeSource`](crate::wasm::RangeInput), for a caller that already holds the whole
+ * asset as bytes.
+ *
+ * # Size ceiling
+ *
+ * The constructor copies the bytes into wasm linear memory, which is 32-bit addressed, so the
+ * asset and everything else the module allocates share a 4 GiB ceiling (a browser tab reaches its
+ * own memory limit well before that). [`BytesSource`] takes the same bytes without the copy, and
+ * [`BlobSource`] holds nothing at all.
+ */
+export class MemorySource {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(data: Uint8Array);
+    readAt(offset: number, length: number): Uint8Array;
+    readonly length: number;
+}
+
+/**
+ * One stream being validated. It owns the session keys and manifest ids its init segments
+ * advertised, so releasing the stream is dropping this object.
+ */
+export class StreamValidation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Everything this stream's init segments have registered, as CBOR for another node to
+     * `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
+     *
+     * Throws an `SdkError` (`STREAM_INVALID`) when a registered session key cannot be
+     * re-encoded.
+     */
+    export(): Uint8Array;
+    /**
+     * Validate a stream segment.
+     *
+     * # Errors
+     *
+     * Throws an `SdkError` on parse or signature failure, or when a media segment arrives
+     * before any init was processed for the stream.
+     */
+    validate(data: RangeSource): Promise<SegmentValidation>;
+}
+
+export class StreamVerifier {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a `StreamVerifier`.
+     *
+     * # Errors
+     *
+     * Throws an `SdkError` (`TRUST_CONFIG_INVALID`) when the trust anchors are invalid.
+     */
+    static create(options: StreamVerifierOptions): StreamVerifier;
+    /**
+     * 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 component that remounts keeps the state its earlier
+     * handle accumulated.
+     */
+    open(stream_id: string): StreamValidation;
+    /**
+     * Open `stream_id` on the state another node exported, merged into whatever this one
+     * holds for that id already.
+     *
+     * # Errors
+     *
+     * Throws an `SdkError` (`STREAM_INVALID`) when `state` is not a value
+     * `StreamValidation.export` produced, or carries a version this SDK no longer reads.
+     */
+    resume(stream_id: string, state: Uint8Array): StreamValidation;
+}
+
+export function init_panic_hook(): void;
+
+/**
+ * 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.
+ *
+ * # Errors
+ *
+ * Throws `READER_INVALID` when the bytes are not a manifest store c2pa can parse.
+ */
+export function parse(manifest: Uint8Array): import('@contentauth/c2pa-types').ManifestStore;
+
+/**
+ * The bytes of one resource in a detached manifest store, or `undefined` 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
+ *
+ * Throws `READER_INVALID` when the bytes are not a manifest store c2pa can parse, or the store
+ * holds the resource but cannot produce it.
+ */
+export function resource(manifest: Uint8Array, uri: string): Uint8Array | undefined;
+
+/**
+ * Every thumbnail the store references, by the `identifier` it references them under: each
+ * manifest's claim thumbnail and each ingredient's, whichever manifest carries them.
+ *
+ * One parse for the whole set, where `resource` pays one per call, so a chain view asks once
+ * instead of once per tile. Render each one as the `format` beside its identifier. A reference
+ * the store cannot produce is left out rather than failing the set.
+ *
+ * # Errors
+ *
+ * Throws `READER_INVALID` when the bytes are not a manifest store c2pa can parse.
+ */
+export function thumbnails(manifest: Uint8Array): Record<string, Uint8Array>;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_binder_free: (a: number, b: number) => void;
+    readonly __wbg_blobsource_free: (a: number, b: number) => void;
+    readonly __wbg_bytessource_free: (a: number, b: number) => void;
+    readonly __wbg_memorysource_free: (a: number, b: number) => void;
+    readonly binder_derive: (a: number, b: any, c: number, d: number) => any;
+    readonly binder_held: (a: any) => [number, number, number];
+    readonly binder_iscc: () => number;
+    readonly blobsource_length: (a: number) => number;
+    readonly blobsource_new: (a: any) => [number, number, number];
+    readonly blobsource_readAt: (a: number, b: number, c: number) => [number, number, number];
+    readonly bytessource_length: (a: number) => number;
+    readonly bytessource_new: (a: any) => number;
+    readonly bytessource_readAt: (a: number, b: number, c: number) => any;
+    readonly memorysource_length: (a: number) => number;
+    readonly memorysource_new: (a: number, b: number) => number;
+    readonly memorysource_readAt: (a: number, b: number, c: number) => any;
+    readonly __wbg_assetverifier_free: (a: number, b: number) => void;
+    readonly assetverifier_create: (a: any) => [number, number, number];
+    readonly assetverifier_verify: (a: number, b: any, c: number, d: number) => any;
+    readonly parse: (a: number, b: number) => [number, number, number];
+    readonly resource: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly thumbnails: (a: number, b: number) => [number, number, number];
+    readonly C2PA_TRUST_LIST: () => [number, number];
+    readonly C2PA_TSA_TRUST_LIST: () => [number, number];
+    readonly DEV_CA: () => [number, number];
+    readonly __wbg_streamvalidation_free: (a: number, b: number) => void;
+    readonly __wbg_streamverifier_free: (a: number, b: number) => void;
+    readonly init_panic_hook: () => void;
+    readonly streamvalidation_export: (a: number) => [number, number, number, number];
+    readonly streamvalidation_validate: (a: number, b: any) => any;
+    readonly streamverifier_create: (a: any) => [number, number, number];
+    readonly streamverifier_open: (a: number, b: number, c: number) => number;
+    readonly streamverifier_resume: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+    readonly __wbg_intounderlyingbytesource_free: (a: number, b: number) => void;
+    readonly intounderlyingbytesource_autoAllocateChunkSize: (a: number) => number;
+    readonly intounderlyingbytesource_cancel: (a: number) => void;
+    readonly intounderlyingbytesource_pull: (a: number, b: any) => any;
+    readonly intounderlyingbytesource_start: (a: number, b: any) => void;
+    readonly intounderlyingbytesource_type: (a: number) => number;
+    readonly __wbg_intounderlyingsource_free: (a: number, b: number) => void;
+    readonly intounderlyingsource_cancel: (a: number) => void;
+    readonly intounderlyingsource_pull: (a: number, b: any) => any;
+    readonly __wbg_intounderlyingsink_free: (a: number, b: number) => void;
+    readonly intounderlyingsink_abort: (a: number, b: any) => any;
+    readonly intounderlyingsink_close: (a: number) => any;
+    readonly intounderlyingsink_write: (a: number, b: any) => any;
+    readonly wasm_bindgen__convert__closures_____invoke__h87666057de2caf05: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h427ac36a6c93c398: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h57ac022b707ce0a7: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hfcd26b19c01d430a: (a: number, b: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;