@limboai/verifox-sdk-plugin-mxf 0.0.9-canary.49db6df

package/gen/ffi/index.d.ts

@@ -0,0 +1,820 @@
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/ffi-types.d.ts
+type UniffiByteArray = Uint8Array;
+declare class RustBuffer {
+  private readOffset;
+  private writeOffset;
+  private capacity;
+  arrayBuffer: ArrayBuffer;
+  private constructor();
+  /**
+   * Allocate a JS-owned buffer of the given capacity. Used by tests; not by
+   * the runtime path, which calls `RustBuffer.fromUint8Array(allocator(n))`
+   * with a runtime-supplied allocator.
+   */
+  static withCapacity(capacity: number): RustBuffer;
+  static empty(): RustBuffer;
+  static fromArrayBuffer(buf: ArrayBuffer): RustBuffer;
+  /**
+   * Construct a `RustBuffer` over a `Uint8Array` view. Cursors track absolute
+   * offsets into the backing `ArrayBuffer`, so `byteOffset` and `byteLength`
+   * delimit the readable/writable region.
+   */
+  static fromUint8Array(view: UniffiByteArray): RustBuffer;
+  get length(): number;
+  get byteArray(): UniffiByteArray;
+  readArrayBuffer(numBytes: number): ArrayBuffer;
+  readByteArray(numBytes: number): UniffiByteArray;
+  writeArrayBuffer(buffer: ArrayBufferLike): void;
+  writeByteArray(src: UniffiByteArray): void;
+  readWithView<T>(numBytes: number, reader: (view: DataView) => T): T;
+  writeWithView(numBytes: number, writer: (view: DataView) => void): void;
+  /**
+   * Advance the read cursor by `numBytes` and return the starting offset.
+   * Used to construct a typed-array view directly over the backing store.
+   */
+  advanceReadOffset(numBytes: number): number;
+  /**
+   * Advance the write cursor by `numBytes` and return the starting offset.
+   * Used to construct a typed-array view directly over the backing store.
+   */
+  advanceWriteOffset(numBytes: number): number;
+  /**
+   * Set the write cursor to an absolute position. Used to backfill after an
+   * in-place encode reports the actual number of bytes written.
+   */
+  setWriteOffset(offset: number): void;
+  protected checkOverflow(start: number, numBytes: number): number;
+}
+//#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;
+  read(from: RustBuffer): TsType;
+  write(value: TsType, into: RustBuffer): void;
+  allocationSize(value: TsType): number;
+}
+//#endregion
+//#region ../../../../../node_modules/@ubjs/core/dist/esm/handle-map.d.ts
+type UniffiHandle = bigint;
+//#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;
+  read(from: RustBuffer): T;
+  write(value: T, into: RustBuffer): void;
+  protected lowerHandle(value: T): UniffiHandle;
+  allocationSize(value: T): number;
+}
+//#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 verifox_plugin_mxf_d_exports {
+  export { Code, FieldViolation, MxfAuthor, MxfAuthorInterface, MxfAuthorLike, MxfPlugin, MxfPluginInterface, MxfPluginLike, RangeSink, RangeSource, Region, SdkError, SdkError_Tags, _default$1 as default };
+}
+/**
+ * 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>;
+}>;
+/**
+ * A byte window a manifest occupies. Structurally identical to the SDKs' `Region`, so 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>;
+}>;
+/**
+ * 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']>;
+/**
+ * A ranged byte source the core lends the plugin. Async because the handle that arrives here is
+ * the SDK's own, whose seam is async so the caller's storage may be a round trip; the two must
+ * agree method for method or the handle cannot cross.
+ *
+ * Both methods are fallible: an infallible `read_at` can only report a failed read as a short
+ * one, indistinguishable from a legitimate end of file, so a storage timeout would silently
+ * author against a truncated asset.
+ */
+interface RangeSource {
+  length(asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<bigint>;
+  readAt(offset: bigint, length: number, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<ArrayBuffer>;
+}
+/**
+ * A ranged read+write backend, for `reserve_slot`. All four methods are first-class: UniFFI has
+ * no trait inheritance for foreign callbacks, so the read half is duplicated from
+ * [`RangeSource`] rather than extended.
+ */
+interface RangeSink {
+  length(asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<bigint>;
+  readAt(offset: bigint, length: number, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<ArrayBuffer>;
+  writeAt(offset: bigint, data: ArrayBuffer, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<void>;
+  setLength(length: bigint, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<void>;
+}
+/**
+ * MXF slot authoring, as the object a host registers on the issuer's `PluginRegistry`.
+ *
+ * The four methods mirror the issuer's `PluginAuthor` exactly. They are declared flat,
+ * because UniFFI has no trait inheritance for foreign callbacks, so the generated binding
+ * satisfies that interface as-is, with nothing in between.
+ */
+interface MxfAuthorLike {
+  /**
+   * The manifest window(s), or empty when the asset carries none. Byte-identical whether
+   * the slot is empty, filled or zeroed: the SDK round-trips this and fails the sign if
+   * it drifts.
+   *
+   * # Errors
+   *
+   * [`SdkError`] when the source cannot be read or the MXF structure is malformed.
+   */
+  locate(src: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<Array<Region>>;
+  /**
+   * The media types this plugin owns. The SDK asserts any `sniff` result is a member.
+   */
+  mediaTypes(): Array<string>;
+  /**
+   * Reserve `reserve` bytes of manifest slot by writing MXF structure through `dst`, and
+   * return exactly where it landed. Never embeds: the SDK writes the signed manifest into
+   * the returned regions.
+   *
+   * # Errors
+   *
+   * [`SdkError`] when the sink cannot be written or `reserve` exceeds a `u32` slot.
+   */
+  reserveSlot(dst: RangeSink, reserve: bigint, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<Array<Region>>;
+  /**
+   * Recognize MXF from the real bytes, or `None` to decline.
+   *
+   * # Errors
+   *
+   * [`SdkError`] when the source cannot be read.
+   */
+  sniff(src: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<string | undefined>;
+}
+/**
+ * @deprecated Use `MxfAuthorLike` instead.
+ */
+type MxfAuthorInterface = MxfAuthorLike;
+/**
+ * MXF slot authoring, as the object a host registers on the issuer's `PluginRegistry`.
+ *
+ * The four methods mirror the issuer's `PluginAuthor` exactly. They are declared flat,
+ * because UniFFI has no trait inheritance for foreign callbacks, so the generated binding
+ * satisfies that interface as-is, with nothing in between.
+ */
+declare class MxfAuthor extends UniffiAbstractObject implements MxfAuthorLike {
+  readonly [uniffiTypeNameSymbol] = "MxfAuthor";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  constructor();
+  /**
+   * The manifest window(s), or empty when the asset carries none. Byte-identical whether
+   * the slot is empty, filled or zeroed: the SDK round-trips this and fails the sign if
+   * it drifts.
+   *
+   * # Errors
+   *
+   * [`SdkError`] when the source cannot be read or the MXF structure is malformed.
+   */
+  locate(src: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<Array<Region>>;
+  /**
+   * The media types this plugin owns. The SDK asserts any `sniff` result is a member.
+   */
+  mediaTypes(): Array<string>;
+  /**
+   * Reserve `reserve` bytes of manifest slot by writing MXF structure through `dst`, and
+   * return exactly where it landed. Never embeds: the SDK writes the signed manifest into
+   * the returned regions.
+   *
+   * # Errors
+   *
+   * [`SdkError`] when the sink cannot be written or `reserve` exceeds a `u32` slot.
+   */
+  reserveSlot(dst: RangeSink, reserve: bigint, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<Array<Region>>;
+  /**
+   * Recognize MXF from the real bytes, or `None` to decline.
+   *
+   * # Errors
+   *
+   * [`SdkError`] when the source cannot be read.
+   */
+  sniff(src: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<string | undefined>;
+  uniffiDestroy(): void;
+  static instanceOf(obj_: any): obj_ is MxfAuthor;
+}
+/**
+ * MXF reading, as the object a host registers on the verifier's `PluginRegistry`.
+ *
+ * The three methods mirror the verifier's `PluginRead` exactly, so the generated binding
+ * satisfies that interface as-is. Carries no libMXF++: locating a slot is pure Rust.
+ */
+interface MxfPluginLike {
+  /**
+   * The manifest window(s), or empty when the asset carries none. What the verifier hashes
+   * around: everything reported here is excluded from the signed content hash.
+   *
+   * # Errors
+   *
+   * [`SdkError`] when the source cannot be read or the MXF structure is malformed.
+   */
+  locate(src: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<Array<Region>>;
+  /**
+   * The media types this plugin owns. The SDK asserts any `sniff` result is a member.
+   */
+  mediaTypes(): Array<string>;
+  /**
+   * Recognize MXF from the real bytes, or `None` to decline.
+   *
+   * # Errors
+   *
+   * [`SdkError`] when the source cannot be read.
+   */
+  sniff(src: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<string | undefined>;
+}
+/**
+ * @deprecated Use `MxfPluginLike` instead.
+ */
+type MxfPluginInterface = MxfPluginLike;
+/**
+ * MXF reading, as the object a host registers on the verifier's `PluginRegistry`.
+ *
+ * The three methods mirror the verifier's `PluginRead` exactly, so the generated binding
+ * satisfies that interface as-is. Carries no libMXF++: locating a slot is pure Rust.
+ */
+declare class MxfPlugin extends UniffiAbstractObject implements MxfPluginLike {
+  readonly [uniffiTypeNameSymbol] = "MxfPlugin";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  constructor();
+  /**
+   * The manifest window(s), or empty when the asset carries none. What the verifier hashes
+   * around: everything reported here is excluded from the signed content hash.
+   *
+   * # Errors
+   *
+   * [`SdkError`] when the source cannot be read or the MXF structure is malformed.
+   */
+  locate(src: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<Array<Region>>;
+  /**
+   * The media types this plugin owns. The SDK asserts any `sniff` result is a member.
+   */
+  mediaTypes(): Array<string>;
+  /**
+   * Recognize MXF from the real bytes, or `None` to decline.
+   *
+   * # Errors
+   *
+   * [`SdkError`] when the source cannot be read.
+   */
+  sniff(src: RangeSource, asyncOpts_?: {
+    signal: AbortSignal;
+  }): Promise<string | undefined>;
+  uniffiDestroy(): void;
+  static instanceOf(obj_: any): obj_ is MxfPlugin;
+}
+/**
+ * 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: {
+    FfiConverterTypeCode: {
+      read(from: RustBuffer): Code;
+      write(value: Code, into: RustBuffer): void;
+      allocationSize(value: Code): number;
+      lift(value: UniffiByteArray): Code;
+      lower(value: Code, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeFieldViolation: {
+      read(from: RustBuffer): FieldViolation;
+      write(value: FieldViolation, into: RustBuffer): void;
+      allocationSize(value: FieldViolation): number;
+      lift(value: UniffiByteArray): FieldViolation;
+      lower(value: FieldViolation, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeMxfAuthor: FfiConverterObject<MxfAuthorLike>;
+    FfiConverterTypeMxfPlugin: FfiConverterObject<MxfPluginLike>;
+    FfiConverterTypeRegion: {
+      read(from: RustBuffer): Region;
+      write(value: Region, into: RustBuffer): void;
+      allocationSize(value: Region): number;
+      lift(value: UniffiByteArray): Region;
+      lower(value: Region, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+    FfiConverterTypeSdkError: {
+      read(from: RustBuffer): SdkError;
+      write(value: SdkError, into: RustBuffer): void;
+      allocationSize(value: SdkError): number;
+      lift(value: UniffiByteArray): SdkError;
+      lower(value: SdkError, alloc: RustBufferAllocator): UniffiByteArray;
+    };
+  };
+}>;
+//#endregion
+//#region ../../../../../target/verifox/codegen/ffi-verifox_plugin_mxf/index.d.ts
+declare function uniffiInitAsync(): Promise<void>;
+declare const _default: {
+  verifox_plugin_mxf: typeof verifox_plugin_mxf_d_exports;
+};
+//#endregion
+export { Code, FieldViolation, MxfAuthor, MxfAuthorInterface, MxfAuthorLike, MxfPlugin, MxfPluginInterface, MxfPluginLike, RangeSink, RangeSource, Region, SdkError, SdkError_Tags, _default as default, uniffiInitAsync };