@trylimbo/sdk-plugin-mxf 0.1.0-canary.96.1.17a82284

package/gen/ffi/index.d.ts

@@ -0,0 +1,822 @@
+//#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;
+//#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;
+}
+//#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_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: {
+      readFromCursor(c: Cursor): Code;
+      writeIntoCursor(value: Code, c: Cursor): void;
+      allocationSize(value: Code): number;
+      lift(value: UniffiByteArray): Code;
+      lower(value: Code, 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;
+    };
+    FfiConverterTypeMxfAuthor: FfiConverterObject<MxfAuthorLike>;
+    FfiConverterTypeMxfPlugin: FfiConverterObject<MxfPluginLike>;
+    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;
+    };
+    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;
+    };
+  };
+}>;
+//#endregion
+//#region ../../../../../target/trylimbo/codegen/ffi-trylimbo_plugin_mxf/index.d.ts
+declare function uniffiInitAsync(): Promise<void>;
+declare const _default: {
+  trylimbo_plugin_mxf: typeof trylimbo_plugin_mxf_d_exports;
+};
+//#endregion
+export { Code, FieldViolation, MxfAuthor, MxfAuthorInterface, MxfAuthorLike, MxfPlugin, MxfPluginInterface, MxfPluginLike, RangeSink, RangeSource, Region, SdkError, SdkError_Tags, _default as default, uniffiInitAsync };