@kenzuya/mediabunny 1.26.0 → 1.28.5

package/dist/mediabunny.d.ts

@@ -1,3319 +0,0 @@
-/// <reference types="dom-mediacapture-transform" />
-/// <reference types="dom-webcodecs" />
-
-/**
- * ADTS input format singleton.
- * @group Input formats
- * @public
- */
-export declare const ADTS: AdtsInputFormat;
-
-/**
- * ADTS file format.
- *
- * Do not instantiate this class; use the {@link ADTS} singleton instead.
- *
- * @group Input formats
- * @public
- */
-export declare class AdtsInputFormat extends InputFormat {
-    get name(): string;
-    get mimeType(): string;
-}
-
-/**
- * ADTS file format.
- * @group Output formats
- * @public
- */
-export declare class AdtsOutputFormat extends OutputFormat {
-    /** Creates a new {@link AdtsOutputFormat} configured with the specified `options`. */
-    constructor(options?: AdtsOutputFormatOptions);
-    getSupportedTrackCounts(): TrackCountLimits;
-    get fileExtension(): string;
-    get mimeType(): string;
-    getSupportedCodecs(): MediaCodec[];
-    get supportsVideoRotationMetadata(): boolean;
-}
-
-/**
- * ADTS-specific output options.
- * @group Output formats
- * @public
- */
-export declare type AdtsOutputFormatOptions = {
-    /**
-     * Will be called for each ADTS frame that is written.
-     *
-     * @param data - The raw bytes.
-     * @param position - The byte offset of the data in the file.
-     */
-    onFrame?: (data: Uint8Array, position: number) => unknown;
-};
-
-/**
- * List of all input format singletons. If you don't need to support all input formats, you should specify the
- * formats individually for better tree shaking.
- * @group Input formats
- * @public
- */
-export declare const ALL_FORMATS: InputFormat[];
-
-/**
- * List of all track types.
- * @group Miscellaneous
- * @public
- */
-export declare const ALL_TRACK_TYPES: readonly ["video", "audio", "subtitle"];
-
-/**
- * Sync or async iterable.
- * @group Miscellaneous
- * @public
- */
-export declare type AnyIterable<T> = Iterable<T> | AsyncIterable<T>;
-
-/**
- * A file attached to a media file.
- *
- * @group Metadata tags
- * @public
- */
-export declare class AttachedFile {
-    /** The raw file data. */
-    data: Uint8Array;
-    /** An RFC 6838 MIME type (e.g. image/jpeg, image/png, font/ttf, etc.) */
-    mimeType?: string | undefined;
-    /** The name of the file. */
-    name?: string | undefined;
-    /** A description of the file. */
-    description?: string | undefined;
-    /** Creates a new {@link AttachedFile}. */
-    constructor(
-    /** The raw file data. */
-    data: Uint8Array, 
-    /** An RFC 6838 MIME type (e.g. image/jpeg, image/png, font/ttf, etc.) */
-    mimeType?: string | undefined, 
-    /** The name of the file. */
-    name?: string | undefined, 
-    /** A description of the file. */
-    description?: string | undefined);
-}
-
-/**
- * An embedded image such as cover art, booklet scan, artwork or preview frame.
- *
- * @group Metadata tags
- * @public
- */
-export declare type AttachedImage = {
-    /** The raw image data. */
-    data: Uint8Array;
-    /** An RFC 6838 MIME type (e.g. image/jpeg, image/png, etc.) */
-    mimeType: string;
-    /** The kind or purpose of the image. */
-    kind: 'coverFront' | 'coverBack' | 'unknown';
-    /** The name of the image file. */
-    name?: string;
-    /** A description of the image. */
-    description?: string;
-};
-
-/**
- * List of known audio codecs, ordered by encoding preference.
- * @group Codecs
- * @public
- */
-export declare const AUDIO_CODECS: readonly ["aac", "opus", "mp3", "vorbis", "flac", "pcm-s16", "pcm-s16be", "pcm-s24", "pcm-s24be", "pcm-s32", "pcm-s32be", "pcm-f32", "pcm-f32be", "pcm-f64", "pcm-f64be", "pcm-u8", "pcm-s8", "ulaw", "alaw"];
-
-/**
- * A sink that retrieves decoded audio samples from an audio track and converts them to `AudioBuffer` instances. This is
- * often more useful than directly retrieving audio samples, as audio buffers can be directly used with the
- * Web Audio API.
- * @group Media sinks
- * @public
- */
-export declare class AudioBufferSink {
-    /** Creates a new {@link AudioBufferSink} for the given {@link InputAudioTrack}. */
-    constructor(audioTrack: InputAudioTrack);
-    /**
-     * Retrieves the audio buffer corresponding to the given timestamp, in seconds. More specifically, returns
-     * the last audio buffer (in presentation order) with a start timestamp less than or equal to the given timestamp.
-     * Returns null if the timestamp is before the track's first timestamp.
-     *
-     * @param timestamp - The timestamp used for retrieval, in seconds.
-     */
-    getBuffer(timestamp: number): Promise<WrappedAudioBuffer | null>;
-    /**
-     * Creates an async iterator that yields audio buffers of this track in presentation order. This method
-     * will intelligently pre-decode a few buffers ahead to enable fast iteration.
-     *
-     * @param startTimestamp - The timestamp in seconds at which to start yielding buffers (inclusive).
-     * @param endTimestamp - The timestamp in seconds at which to stop yielding buffers (exclusive).
-     */
-    buffers(startTimestamp?: number, endTimestamp?: number): AsyncGenerator<WrappedAudioBuffer, void, unknown>;
-    /**
-     * Creates an async iterator that yields an audio buffer for each timestamp in the argument. This method
-     * uses an optimized decoding pipeline if these timestamps are monotonically sorted, decoding each packet at most
-     * once, and is therefore more efficient than manually getting the buffer for every timestamp. The iterator may
-     * yield null if no buffer is available for a given timestamp.
-     *
-     * @param timestamps - An iterable or async iterable of timestamps in seconds.
-     */
-    buffersAtTimestamps(timestamps: AnyIterable<number>): AsyncGenerator<WrappedAudioBuffer | null, void, unknown>;
-}
-
-/**
- * This source can be used to add audio data from an AudioBuffer to the output track. This is useful when working with
- * the Web Audio API.
- * @group Media sources
- * @public
- */
-export declare class AudioBufferSource extends AudioSource {
-    /**
-     * Creates a new {@link AudioBufferSource} whose `AudioBuffer` instances are encoded according to the specified
-     * {@link AudioEncodingConfig}.
-     */
-    constructor(encodingConfig: AudioEncodingConfig);
-    /**
-     * Converts an AudioBuffer to audio samples, encodes them and adds them to the output. The first AudioBuffer will
-     * be played at timestamp 0, and any subsequent AudioBuffer will have a timestamp equal to the total duration of
-     * all previous AudioBuffers.
-     *
-     * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
-     * to respect writer and encoder backpressure.
-     */
-    add(audioBuffer: AudioBuffer): Promise<void>;
-}
-
-/**
- * Union type of known audio codecs.
- * @group Codecs
- * @public
- */
-export declare type AudioCodec = typeof AUDIO_CODECS[number];
-
-/**
- * Additional options that control audio encoding.
- * @group Encoding
- * @public
- */
-export declare type AudioEncodingAdditionalOptions = {
-    /** Configures the bitrate mode. */
-    bitrateMode?: 'constant' | 'variable';
-    /**
-     * The full codec string as specified in the WebCodecs Codec Registry. This string must match the codec
-     * specified in `codec`. When not set, a fitting codec string will be constructed automatically by the library.
-     */
-    fullCodecString?: string;
-};
-
-/**
- * Configuration object that controls audio encoding. Can be used to set codec, quality, and more.
- * @group Encoding
- * @public
- */
-export declare type AudioEncodingConfig = {
-    /** The audio codec that should be used for encoding the audio samples. */
-    codec: AudioCodec;
-    /**
-     * The target bitrate for the encoded audio, in bits per second. Alternatively, a subjective {@link Quality} can
-     * be provided. Required for compressed audio codecs, unused for PCM codecs.
-     */
-    bitrate?: number | Quality;
-    /** Called for each successfully encoded packet. Both the packet and the encoding metadata are passed. */
-    onEncodedPacket?: (packet: EncodedPacket, meta: EncodedAudioChunkMetadata | undefined) => unknown;
-    /**
-     * Called when the internal [encoder config](https://www.w3.org/TR/webcodecs/#audio-encoder-config), as used by the
-     * WebCodecs API, is created.
-     */
-    onEncoderConfig?: (config: AudioEncoderConfig) => unknown;
-} & AudioEncodingAdditionalOptions;
-
-/**
- * Represents a raw, unencoded audio sample. Mainly used as an expressive wrapper around WebCodecs API's
- * [`AudioData`](https://developer.mozilla.org/en-US/docs/Web/API/AudioData), but can also be used standalone.
- * @group Samples
- * @public
- */
-export declare class AudioSample implements Disposable {
-    /**
-     * The audio sample format.
-     * [See sample formats](https://developer.mozilla.org/en-US/docs/Web/API/AudioData/format)
-     */
-    readonly format: AudioSampleFormat;
-    /** The audio sample rate in hertz. */
-    readonly sampleRate: number;
-    /**
-     * The number of audio frames in the sample, per channel. In other words, the length of this audio sample in frames.
-     */
-    readonly numberOfFrames: number;
-    /** The number of audio channels. */
-    readonly numberOfChannels: number;
-    /** The duration of the sample in seconds. */
-    readonly duration: number;
-    /**
-     * The presentation timestamp of the sample in seconds. May be negative. Samples with negative end timestamps should
-     * not be presented.
-     */
-    readonly timestamp: number;
-    /** The presentation timestamp of the sample in microseconds. */
-    get microsecondTimestamp(): number;
-    /** The duration of the sample in microseconds. */
-    get microsecondDuration(): number;
-    /**
-     * Creates a new {@link AudioSample}, either from an existing
-     * [`AudioData`](https://developer.mozilla.org/en-US/docs/Web/API/AudioData) or from raw bytes specified in
-     * {@link AudioSampleInit}.
-     */
-    constructor(init: AudioData | AudioSampleInit);
-    /** Returns the number of bytes required to hold the audio sample's data as specified by the given options. */
-    allocationSize(options: AudioSampleCopyToOptions): number;
-    /** Copies the audio sample's data to an ArrayBuffer or ArrayBufferView as specified by the given options. */
-    copyTo(destination: AllowSharedBufferSource, options: AudioSampleCopyToOptions): void;
-    /** Clones this audio sample. */
-    clone(): AudioSample;
-    /**
-     * Closes this audio sample, releasing held resources. Audio samples should be closed as soon as they are not
-     * needed anymore.
-     */
-    close(): void;
-    /**
-     * Converts this audio sample to an AudioData for use with the WebCodecs API. The AudioData returned by this
-     * method *must* be closed separately from this audio sample.
-     */
-    toAudioData(): AudioData;
-    /** Convert this audio sample to an AudioBuffer for use with the Web Audio API. */
-    toAudioBuffer(): AudioBuffer;
-    /** Sets the presentation timestamp of this audio sample, in seconds. */
-    setTimestamp(newTimestamp: number): void;
-    /** Calls `.close()`. */
-    [Symbol.dispose](): void;
-    /**
-     * Creates AudioSamples from an AudioBuffer, starting at the given timestamp in seconds. Typically creates exactly
-     * one sample, but may create multiple if the AudioBuffer is exceedingly large.
-     */
-    static fromAudioBuffer(audioBuffer: AudioBuffer, timestamp: number): AudioSample[];
-}
-
-/**
- * Options used for copying audio sample data.
- * @group Samples
- * @public
- */
-export declare type AudioSampleCopyToOptions = {
-    /**
-     * The index identifying the plane to copy from. This must be 0 if using a non-planar (interleaved) output format.
-     */
-    planeIndex: number;
-    /**
-     * The output format for the destination data. Defaults to the AudioSample's format.
-     * [See sample formats](https://developer.mozilla.org/en-US/docs/Web/API/AudioData/format)
-     */
-    format?: AudioSampleFormat;
-    /** An offset into the source plane data indicating which frame to begin copying from. Defaults to 0. */
-    frameOffset?: number;
-    /**
-     * The number of frames to copy. If not provided, the copy will include all frames in the plane beginning
-     * with frameOffset.
-     */
-    frameCount?: number;
-};
-
-/**
- * Metadata used for AudioSample initialization.
- * @group Samples
- * @public
- */
-export declare type AudioSampleInit = {
-    /** The audio data for this sample. */
-    data: AllowSharedBufferSource;
-    /**
-     * The audio sample format. [See sample formats](https://developer.mozilla.org/en-US/docs/Web/API/AudioData/format)
-     */
-    format: AudioSampleFormat;
-    /** The number of audio channels. */
-    numberOfChannels: number;
-    /** The audio sample rate in hertz. */
-    sampleRate: number;
-    /** The presentation timestamp of the sample in seconds. */
-    timestamp: number;
-};
-
-/**
- * Sink for retrieving decoded audio samples from an audio track.
- * @group Media sinks
- * @public
- */
-export declare class AudioSampleSink extends BaseMediaSampleSink<AudioSample> {
-    /** Creates a new {@link AudioSampleSink} for the given {@link InputAudioTrack}. */
-    constructor(audioTrack: InputAudioTrack);
-    /**
-     * Retrieves the audio sample corresponding to the given timestamp, in seconds. More specifically, returns
-     * the last audio sample (in presentation order) with a start timestamp less than or equal to the given timestamp.
-     * Returns null if the timestamp is before the track's first timestamp.
-     *
-     * @param timestamp - The timestamp used for retrieval, in seconds.
-     */
-    getSample(timestamp: number): Promise<AudioSample | null>;
-    /**
-     * Creates an async iterator that yields the audio samples of this track in presentation order. This method
-     * will intelligently pre-decode a few samples ahead to enable fast iteration.
-     *
-     * @param startTimestamp - The timestamp in seconds at which to start yielding samples (inclusive).
-     * @param endTimestamp - The timestamp in seconds at which to stop yielding samples (exclusive).
-     */
-    samples(startTimestamp?: number, endTimestamp?: number): AsyncGenerator<AudioSample, void, unknown>;
-    /**
-     * Creates an async iterator that yields an audio sample for each timestamp in the argument. This method
-     * uses an optimized decoding pipeline if these timestamps are monotonically sorted, decoding each packet at most
-     * once, and is therefore more efficient than manually getting the sample for every timestamp. The iterator may
-     * yield null if no sample is available for a given timestamp.
-     *
-     * @param timestamps - An iterable or async iterable of timestamps in seconds.
-     */
-    samplesAtTimestamps(timestamps: AnyIterable<number>): AsyncGenerator<AudioSample | null, void, unknown>;
-}
-
-/**
- * This source can be used to add raw, unencoded audio samples to an output audio track. These samples will
- * automatically be encoded and then piped into the output.
- * @group Media sources
- * @public
- */
-export declare class AudioSampleSource extends AudioSource {
-    /**
-     * Creates a new {@link AudioSampleSource} whose samples are encoded according to the specified
-     * {@link AudioEncodingConfig}.
-     */
-    constructor(encodingConfig: AudioEncodingConfig);
-    /**
-     * Encodes an audio sample and then adds it to the output.
-     *
-     * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
-     * to respect writer and encoder backpressure.
-     */
-    add(audioSample: AudioSample): Promise<void>;
-}
-
-/**
- * Base class for audio sources - sources for audio tracks.
- * @group Media sources
- * @public
- */
-export declare abstract class AudioSource extends MediaSource_2 {
-    /** Internal constructor. */
-    constructor(codec: AudioCodec);
-}
-
-/**
- * Additional metadata for audio tracks.
- * @group Output files
- * @public
- */
-export declare type AudioTrackMetadata = BaseTrackMetadata & {};
-
-/**
- * Base class for decoded media sample sinks.
- * @group Media sinks
- * @public
- */
-export declare abstract class BaseMediaSampleSink<MediaSample extends VideoSample | AudioSample> {
-}
-
-/**
- * Base track metadata, applicable to all tracks.
- * @group Output files
- * @public
- */
-export declare type BaseTrackMetadata = {
-    /** The three-letter, ISO 639-2/T language code specifying the language of this track. */
-    languageCode?: string;
-    /** A user-defined name for this track, like "English" or "Director Commentary". */
-    name?: string;
-    /** The track's disposition, i.e. information about its intended usage. */
-    disposition?: Partial<TrackDisposition>;
-    /**
-     * The maximum amount of encoded packets that will be added to this track. Setting this field provides the muxer
-     * with an additional signal that it can use to preallocate space in the file.
-     *
-     * When this field is set, it is an error to provide more packets than whatever this field specifies.
-     *
-     * Predicting the maximum packet count requires considering both the maximum duration as well as the codec.
-     * - For video codecs, you can assume one packet per frame.
-     * - For audio codecs, there is one packet for each "audio chunk", the duration of which depends on the codec. For
-     * simplicity, you can assume each packet is roughly 10 ms or 512 samples long, whichever is shorter.
-     * - For subtitles, assume each cue and each gap in the subtitles adds a packet.
-     *
-     * If you're not fully sure, make sure to add a buffer of around 33% to make sure you stay below the maximum.
-     */
-    maximumPacketCount?: number;
-};
-
-/**
- * A source backed by a [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob). Since a
- * [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) is also a `Blob`, this is the source to use when
- * reading files off the disk.
- * @group Input sources
- * @public
- */
-export declare class BlobSource extends Source {
-    /**
-     * Creates a new {@link BlobSource} backed by the specified
-     * [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob).
-     */
-    constructor(blob: Blob, options?: BlobSourceOptions);
-}
-
-/**
- * Options for {@link BlobSource}.
- * @group Input sources
- * @public
- */
-export declare type BlobSourceOptions = {
-    /** The maximum number of bytes the cache is allowed to hold in memory. Defaults to 8 MiB. */
-    maxCacheSize?: number;
-};
-
-/**
- * A source backed by an ArrayBuffer or ArrayBufferView, with the entire file held in memory.
- * @group Input sources
- * @public
- */
-declare class BufferSource_2 extends Source {
-    /** Creates a new {@link BufferSource} backed the specified `ArrayBuffer` or `ArrayBufferView`. */
-    constructor(buffer: ArrayBuffer | ArrayBufferView);
-}
-export { BufferSource_2 as BufferSource }
-
-/**
- * A target that writes data directly into an ArrayBuffer in memory. Great for performance, but not suitable for very
- * large files. The buffer will be available once the output has been finalized.
- * @group Output targets
- * @public
- */
-export declare class BufferTarget extends Target {
-    /** Stores the final output buffer. Until the output is finalized, this will be `null`. */
-    buffer: ArrayBuffer | null;
-}
-
-/**
- * Checks if the browser is able to encode the given codec.
- * @group Encoding
- * @public
- */
-export declare const canEncode: (codec: MediaCodec) => Promise<boolean>;
-
-/**
- * Checks if the browser is able to encode the given audio codec with the given parameters.
- * @group Encoding
- * @public
- */
-export declare const canEncodeAudio: (codec: AudioCodec, options?: {
-    numberOfChannels?: number;
-    sampleRate?: number;
-    bitrate?: number | Quality;
-} & AudioEncodingAdditionalOptions) => Promise<boolean>;
-
-/**
- * Checks if the browser is able to encode the given subtitle codec.
- * @group Encoding
- * @public
- */
-export declare const canEncodeSubtitles: (codec: SubtitleCodec) => Promise<boolean>;
-
-/**
- * Checks if the browser is able to encode the given video codec with the given parameters.
- * @group Encoding
- * @public
- */
-export declare const canEncodeVideo: (codec: VideoCodec, options?: {
-    width?: number;
-    height?: number;
-    bitrate?: number | Quality;
-} & VideoEncodingAdditionalOptions) => Promise<boolean>;
-
-/**
- * A sink that renders video samples (frames) of the given video track to canvases. This is often more useful than
- * directly retrieving frames, as it comes with common preprocessing steps such as resizing or applying rotation
- * metadata.
- *
- * This sink will yield `HTMLCanvasElement`s when in a DOM context, and `OffscreenCanvas`es otherwise.
- *
- * @group Media sinks
- * @public
- */
-export declare class CanvasSink {
-    /** Creates a new {@link CanvasSink} for the given {@link InputVideoTrack}. */
-    constructor(videoTrack: InputVideoTrack, options?: CanvasSinkOptions);
-    /**
-     * Retrieves a canvas with the video frame corresponding to the given timestamp, in seconds. More specifically,
-     * returns the last video frame (in presentation order) with a start timestamp less than or equal to the given
-     * timestamp. Returns null if the timestamp is before the track's first timestamp.
-     *
-     * @param timestamp - The timestamp used for retrieval, in seconds.
-     */
-    getCanvas(timestamp: number): Promise<WrappedCanvas | null>;
-    /**
-     * Creates an async iterator that yields canvases with the video frames of this track in presentation order. This
-     * method will intelligently pre-decode a few frames ahead to enable fast iteration.
-     *
-     * @param startTimestamp - The timestamp in seconds at which to start yielding canvases (inclusive).
-     * @param endTimestamp - The timestamp in seconds at which to stop yielding canvases (exclusive).
-     */
-    canvases(startTimestamp?: number, endTimestamp?: number): AsyncGenerator<WrappedCanvas, void, unknown>;
-    /**
-     * Creates an async iterator that yields a canvas for each timestamp in the argument. This method uses an optimized
-     * decoding pipeline if these timestamps are monotonically sorted, decoding each packet at most once, and is
-     * therefore more efficient than manually getting the canvas for every timestamp. The iterator may yield null if
-     * no frame is available for a given timestamp.
-     *
-     * @param timestamps - An iterable or async iterable of timestamps in seconds.
-     */
-    canvasesAtTimestamps(timestamps: AnyIterable<number>): AsyncGenerator<WrappedCanvas | null, void, unknown>;
-}
-
-/**
- * Options for constructing a CanvasSink.
- * @group Media sinks
- * @public
- */
-export declare type CanvasSinkOptions = {
-    /**
-     * Whether the output canvases should have transparency instead of a black background. Defaults to `false`. Set
-     * this to `true` when using this sink to read transparent videos.
-     */
-    alpha?: boolean;
-    /**
-     * The width of the output canvas in pixels, defaulting to the display width of the video track. If height is not
-     * set, it will be deduced automatically based on aspect ratio.
-     */
-    width?: number;
-    /**
-     * The height of the output canvas in pixels, defaulting to the display height of the video track. If width is not
-     * set, it will be deduced automatically based on aspect ratio.
-     */
-    height?: number;
-    /**
-     * The fitting algorithm in case both width and height are set.
-     *
-     * - `'fill'` will stretch the image to fill the entire box, potentially altering aspect ratio.
-     * - `'contain'` will contain the entire image within the box while preserving aspect ratio. This may lead to
-     * letterboxing.
-     * - `'cover'` will scale the image until the entire box is filled, while preserving aspect ratio.
-     */
-    fit?: 'fill' | 'contain' | 'cover';
-    /**
-     * The clockwise rotation by which to rotate the raw video frame. Defaults to the rotation set in the file metadata.
-     * Rotation is applied before resizing.
-     */
-    rotation?: Rotation;
-    /**
-     * Specifies the rectangular region of the input video to crop to. The crop region will automatically be clamped to
-     * the dimensions of the input video track. Cropping is performed after rotation but before resizing.
-     */
-    crop?: CropRectangle;
-    /**
-     * When set, specifies the number of canvases in the pool. These canvases will be reused in a ring buffer /
-     * round-robin type fashion. This keeps the amount of allocated VRAM constant and relieves the browser from
-     * constantly allocating/deallocating canvases. A pool size of 0 or `undefined` disables the pool and means a new
-     * canvas is created each time.
-     */
-    poolSize?: number;
-};
-
-/**
- * This source can be used to add video frames to the output track from a fixed canvas element. Since canvases are often
- * used for rendering, this source provides a convenient wrapper around {@link VideoSampleSource}.
- * @group Media sources
- * @public
- */
-export declare class CanvasSource extends VideoSource {
-    /**
-     * Creates a new {@link CanvasSource} from a canvas element or `OffscreenCanvas` whose samples are encoded
-     * according to the specified {@link VideoEncodingConfig}.
-     */
-    constructor(canvas: HTMLCanvasElement | OffscreenCanvas, encodingConfig: VideoEncodingConfig);
-    /**
-     * Captures the current canvas state as a video sample (frame), encodes it and adds it to the output.
-     *
-     * @param timestamp - The timestamp of the sample, in seconds.
-     * @param duration - The duration of the sample, in seconds.
-     *
-     * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
-     * to respect writer and encoder backpressure.
-     */
-    add(timestamp: number, duration?: number, encodeOptions?: VideoEncoderEncodeOptions): Promise<void>;
-}
-
-/**
- * Represents a media file conversion process, used to convert one media file into another. In addition to conversion,
- * this class can be used to resize and rotate video, resample audio, drop tracks, or trim to a specific time range.
- * @group Conversion
- * @public
- */
-export declare class Conversion {
-    /** The input file. */
-    readonly input: Input;
-    /** The output file. */
-    readonly output: Output;
-    /**
-     * A callback that is fired whenever the conversion progresses. Returns a number between 0 and 1, indicating the
-     * completion of the conversion. Note that a progress of 1 doesn't necessarily mean the conversion is complete;
-     * the conversion is complete once `execute()` resolves.
-     *
-     * In order for progress to be computed, this property must be set before `execute` is called.
-     */
-    onProgress?: (progress: number) => unknown;
-    /**
-     * Whether this conversion, as it has been configured, is valid and can be executed. If this field is `false`, check
-     * the `discardedTracks` field for reasons.
-     */
-    isValid: boolean;
-    /** The list of tracks that are included in the output file. */
-    readonly utilizedTracks: InputTrack[];
-    /** The list of tracks from the input file that have been discarded, alongside the discard reason. */
-    readonly discardedTracks: DiscardedTrack[];
-    /** Initializes a new conversion process without starting the conversion. */
-    static init(options: ConversionOptions): Promise<Conversion>;
-    /** Creates a new Conversion instance (duh). */
-    private constructor();
-    /**
-     * Adds an external subtitle track to the output. This can be called after `init()` but before `execute()`.
-     * This is useful for adding subtitle tracks from separate files that are not part of the input video.
-     *
-     * @param source - The subtitle source to add
-     * @param metadata - Optional metadata for the subtitle track
-     * @param contentProvider - Optional async function that will be called after the output starts to add content to the subtitle source
-     */
-    addExternalSubtitleTrack(source: SubtitleSource, metadata?: SubtitleTrackMetadata, contentProvider?: () => Promise<void>): void;
-    /**
-     * Executes the conversion process. Resolves once conversion is complete.
-     *
-     * Will throw if `isValid` is `false`.
-     */
-    execute(): Promise<void>;
-    /** Cancels the conversion process. Does nothing if the conversion is already complete. */
-    cancel(): Promise<void>;
-}
-
-/**
- * Audio-specific options.
- * @group Conversion
- * @public
- */
-export declare type ConversionAudioOptions = {
-    /** If `true`, all audio tracks will be discarded and will not be present in the output. */
-    discard?: boolean;
-    /** The desired channel count of the output audio. */
-    numberOfChannels?: number;
-    /** The desired sample rate of the output audio, in hertz. */
-    sampleRate?: number;
-    /** The desired output audio codec. */
-    codec?: AudioCodec;
-    /** The desired bitrate of the output audio. */
-    bitrate?: number | Quality;
-    /** When `true`, audio will always be re-encoded instead of directly copying over the encoded samples. */
-    forceTranscode?: boolean;
-    /**
-     * Allows for custom user-defined processing of audio samples, e.g. for applying audio effects, transformations, or
-     * timestamp modifications. Will be called for each input audio sample after remixing and resampling.
-     *
-     * Must return an {@link AudioSample}, an array of them, or `null` for dropping the sample.
-     *
-     * This function can also be used to manually perform remixing or resampling. When doing so, you should signal the
-     * post-process parameters using the `processedNumberOfChannels` and `processedSampleRate` fields, which enables the
-     * encoder to better know what to expect. If these fields aren't set, Mediabunny will assume you won't perform
-     * remixing or resampling.
-     */
-    process?: (sample: AudioSample) => MaybePromise<AudioSample | AudioSample[] | null>;
-    /**
-     * An optional hint specifying the channel count of audio samples returned by the `process` function, for better
-     * encoder configuration.
-     */
-    processedNumberOfChannels?: number;
-    /**
-     * An optional hint specifying the sample rate of audio samples returned by the `process` function, for better
-     * encoder configuration.
-     */
-    processedSampleRate?: number;
-};
-
-/**
- * The options for media file conversion.
- * @group Conversion
- * @public
- */
-export declare type ConversionOptions = {
-    /** The input file. */
-    input: Input;
-    /** The output file. */
-    output: Output;
-    /**
-     * Video-specific options. When passing an object, the same options are applied to all video tracks. When passing a
-     * function, it will be invoked for each video track and is expected to return or resolve to the options
-     * for that specific track. The function is passed an instance of {@link InputVideoTrack} as well as a number `n`,
-     * which is the 1-based index of the track in the list of all video tracks.
-     */
-    video?: ConversionVideoOptions | ((track: InputVideoTrack, n: number) => MaybePromise<ConversionVideoOptions | undefined>);
-    /**
-     * Audio-specific options. When passing an object, the same options are applied to all audio tracks. When passing a
-     * function, it will be invoked for each audio track and is expected to return or resolve to the options
-     * for that specific track. The function is passed an instance of {@link InputAudioTrack} as well as a number `n`,
-     * which is the 1-based index of the track in the list of all audio tracks.
-     */
-    audio?: ConversionAudioOptions | ((track: InputAudioTrack, n: number) => MaybePromise<ConversionAudioOptions | undefined>);
-    /**
-     * Subtitle-specific options. When passing an object, the same options are applied to all subtitle tracks. When passing a
-     * function, it will be invoked for each subtitle track and is expected to return or resolve to the options
-     * for that specific track. The function is passed an instance of {@link InputSubtitleTrack} as well as a number `n`,
-     * which is the 1-based index of the track in the list of all subtitle tracks.
-     */
-    subtitle?: ConversionSubtitleOptions | ((track: InputSubtitleTrack, n: number) => MaybePromise<ConversionSubtitleOptions | undefined>);
-    /** Options to trim the input file. */
-    trim?: {
-        /** The time in the input file in seconds at which the output file should start. Must be less than `end`.  */
-        start: number;
-        /** The time in the input file in seconds at which the output file should end. Must be greater than `start`. */
-        end: number;
-    };
-    /**
-     * An object or a callback that returns or resolves to an object containing the descriptive metadata tags that
-     * should be written to the output file. If a function is passed, it will be passed the tags of the input file as
-     * its first argument, allowing you to modify, augment or extend them.
-     *
-     * If no function is set, the input's metadata tags will be copied to the output.
-     */
-    tags?: MetadataTags | ((inputTags: MetadataTags) => MaybePromise<MetadataTags>);
-    /**
-     * Whether to show potential console warnings about discarded tracks after calling `Conversion.init()`, defaults to
-     * `true`. Set this to `false` if you're properly handling the `discardedTracks` and `isValid` fields already and
-     * want to keep the console output clean.
-     */
-    showWarnings?: boolean;
-};
-
-/**
- * Subtitle-specific options.
- * @group Conversion
- * @public
- */
-export declare type ConversionSubtitleOptions = {
-    /** If `true`, all subtitle tracks will be discarded and will not be present in the output. */
-    discard?: boolean;
-    /** The desired output subtitle codec. */
-    codec?: SubtitleCodec;
-};
-
-/**
- * Video-specific options.
- * @group Conversion
- * @public
- */
-export declare type ConversionVideoOptions = {
-    /** If `true`, all video tracks will be discarded and will not be present in the output. */
-    discard?: boolean;
-    /**
-     * The desired width of the output video in pixels, defaulting to the video's natural display width. If height
-     * is not set, it will be deduced automatically based on aspect ratio.
-     */
-    width?: number;
-    /**
-     * The desired height of the output video in pixels, defaulting to the video's natural display height. If width
-     * is not set, it will be deduced automatically based on aspect ratio.
-     */
-    height?: number;
-    /**
-     * The fitting algorithm in case both width and height are set, or if the input video changes its size over time.
-     *
-     * - `'fill'` will stretch the image to fill the entire box, potentially altering aspect ratio.
-     * - `'contain'` will contain the entire image within the box while preserving aspect ratio. This may lead to
-     * letterboxing.
-     * - `'cover'` will scale the image until the entire box is filled, while preserving aspect ratio.
-     */
-    fit?: 'fill' | 'contain' | 'cover';
-    /**
-     * The angle in degrees to rotate the input video by, clockwise. Rotation is applied before cropping and resizing.
-     * This rotation is _in addition to_ the natural rotation of the input video as specified in input file's metadata.
-     */
-    rotate?: Rotation;
-    /**
-     * Specifies the rectangular region of the input video to crop to. The crop region will automatically be clamped to
-     * the dimensions of the input video track. Cropping is performed after rotation but before resizing.
-     */
-    crop?: {
-        /** The distance in pixels from the left edge of the source frame to the left edge of the crop rectangle. */
-        left: number;
-        /** The distance in pixels from the top edge of the source frame to the top edge of the crop rectangle. */
-        top: number;
-        /** The width in pixels of the crop rectangle. */
-        width: number;
-        /** The height in pixels of the crop rectangle. */
-        height: number;
-    };
-    /**
-     * The desired frame rate of the output video, in hertz. If not specified, the original input frame rate will
-     * be used (which may be variable).
-     */
-    frameRate?: number;
-    /** The desired output video codec. */
-    codec?: VideoCodec;
-    /** The desired bitrate of the output video. */
-    bitrate?: number | Quality;
-    /**
-     * Whether to discard or keep the transparency information of the input video. The default is `'discard'`. Note that
-     * for `'keep'` to produce a transparent video, you must use an output config that supports it, such as WebM with
-     * VP9.
-     */
-    alpha?: 'discard' | 'keep';
-    /**
-     * The interval, in seconds, of how often frames are encoded as a key frame. The default is 5 seconds. Frequent key
-     * frames improve seeking behavior but increase file size. When using multiple video tracks, you should give them
-     * all the same key frame interval.
-     *
-     * Setting this fields forces a transcode.
-     */
-    keyFrameInterval?: number;
-    /** When `true`, video will always be re-encoded instead of directly copying over the encoded samples. */
-    forceTranscode?: boolean;
-    /**
-     * Allows for custom user-defined processing of video frames, e.g. for applying overlays, color transformations, or
-     * timestamp modifications. Will be called for each input video sample after transformations and frame rate
-     * corrections.
-     *
-     * Must return a {@link VideoSample} or a `CanvasImageSource`, an array of them, or `null` for dropping the frame.
-     * When non-timestamped data is returned, the timestamp and duration from the source sample will be used. Rotation
-     * metadata of the returned sample will be ignored.
-     *
-     * This function can also be used to manually resize frames. When doing so, you should signal the post-process
-     * dimensions using the `processedWidth` and `processedHeight` fields, which enables the encoder to better know what
-     * to expect. If these fields aren't set, Mediabunny will assume you won't perform any resizing.
-     */
-    process?: (sample: VideoSample) => MaybePromise<CanvasImageSource | VideoSample | (CanvasImageSource | VideoSample)[] | null>;
-    /**
-     * An optional hint specifying the width of video samples returned by the `process` function, for better
-     * encoder configuration.
-     */
-    processedWidth?: number;
-    /**
-     * An optional hint specifying the height of video samples returned by the `process` function, for better
-     * encoder configuration.
-     */
-    processedHeight?: number;
-};
-
-/**
- * Specifies the rectangular cropping region.
- * @group Miscellaneous
- * @public
- */
-export declare type CropRectangle = {
-    /** The distance in pixels from the left edge of the source frame to the left edge of the crop rectangle. */
-    left: number;
-    /** The distance in pixels from the top edge of the source frame to the top edge of the crop rectangle. */
-    top: number;
-    /** The width in pixels of the crop rectangle. */
-    width: number;
-    /** The height in pixels of the crop rectangle. */
-    height: number;
-};
-
-/**
- * Base class for custom audio decoders. To add your own custom audio decoder, extend this class, implement the
- * abstract methods and static `supports` method, and register the decoder using {@link registerDecoder}.
- * @group Custom coders
- * @public
- */
-export declare abstract class CustomAudioDecoder {
-    /** The input audio's codec. */
-    readonly codec: AudioCodec;
-    /** The input audio's decoder config. */
-    readonly config: AudioDecoderConfig;
-    /** The callback to call when a decoded AudioSample is available. */
-    readonly onSample: (sample: AudioSample) => unknown;
-    /** Returns true if and only if the decoder can decode the given codec configuration. */
-    static supports(codec: AudioCodec, config: AudioDecoderConfig): boolean;
-    /** Called after decoder creation; can be used for custom initialization logic. */
-    abstract init(): MaybePromise<void>;
-    /** Decodes the provided encoded packet. */
-    abstract decode(packet: EncodedPacket): MaybePromise<void>;
-    /** Decodes all remaining packets and then resolves. */
-    abstract flush(): MaybePromise<void>;
-    /** Called when the decoder is no longer needed and its resources can be freed. */
-    abstract close(): MaybePromise<void>;
-}
-
-/**
- * Base class for custom audio encoders. To add your own custom audio encoder, extend this class, implement the
- * abstract methods and static `supports` method, and register the encoder using {@link registerEncoder}.
- * @group Custom coders
- * @public
- */
-export declare abstract class CustomAudioEncoder {
-    /** The codec with which to encode the audio. */
-    readonly codec: AudioCodec;
-    /** Config for the encoder. */
-    readonly config: AudioEncoderConfig;
-    /** The callback to call when an EncodedPacket is available. */
-    readonly onPacket: (packet: EncodedPacket, meta?: EncodedAudioChunkMetadata) => unknown;
-    /** Returns true if and only if the encoder can encode the given codec configuration. */
-    static supports(codec: AudioCodec, config: AudioEncoderConfig): boolean;
-    /** Called after encoder creation; can be used for custom initialization logic. */
-    abstract init(): MaybePromise<void>;
-    /** Encodes the provided audio sample. */
-    abstract encode(audioSample: AudioSample): MaybePromise<void>;
-    /** Encodes all remaining audio samples and then resolves. */
-    abstract flush(): MaybePromise<void>;
-    /** Called when the encoder is no longer needed and its resources can be freed. */
-    abstract close(): MaybePromise<void>;
-}
-
-/**
- * Base class for custom video decoders. To add your own custom video decoder, extend this class, implement the
- * abstract methods and static `supports` method, and register the decoder using {@link registerDecoder}.
- * @group Custom coders
- * @public
- */
-export declare abstract class CustomVideoDecoder {
-    /** The input video's codec. */
-    readonly codec: VideoCodec;
-    /** The input video's decoder config. */
-    readonly config: VideoDecoderConfig;
-    /** The callback to call when a decoded VideoSample is available. */
-    readonly onSample: (sample: VideoSample) => unknown;
-    /** Returns true if and only if the decoder can decode the given codec configuration. */
-    static supports(codec: VideoCodec, config: VideoDecoderConfig): boolean;
-    /** Called after decoder creation; can be used for custom initialization logic. */
-    abstract init(): MaybePromise<void>;
-    /** Decodes the provided encoded packet. */
-    abstract decode(packet: EncodedPacket): MaybePromise<void>;
-    /** Decodes all remaining packets and then resolves. */
-    abstract flush(): MaybePromise<void>;
-    /** Called when the decoder is no longer needed and its resources can be freed. */
-    abstract close(): MaybePromise<void>;
-}
-
-/**
- * Base class for custom video encoders. To add your own custom video encoder, extend this class, implement the
- * abstract methods and static `supports` method, and register the encoder using {@link registerEncoder}.
- * @group Custom coders
- * @public
- */
-export declare abstract class CustomVideoEncoder {
-    /** The codec with which to encode the video. */
-    readonly codec: VideoCodec;
-    /** Config for the encoder. */
-    readonly config: VideoEncoderConfig;
-    /** The callback to call when an EncodedPacket is available. */
-    readonly onPacket: (packet: EncodedPacket, meta?: EncodedVideoChunkMetadata) => unknown;
-    /** Returns true if and only if the encoder can encode the given codec configuration. */
-    static supports(codec: VideoCodec, config: VideoEncoderConfig): boolean;
-    /** Called after encoder creation; can be used for custom initialization logic. */
-    abstract init(): MaybePromise<void>;
-    /** Encodes the provided video sample. */
-    abstract encode(videoSample: VideoSample, options: VideoEncoderEncodeOptions): MaybePromise<void>;
-    /** Encodes all remaining video samples and then resolves. */
-    abstract flush(): MaybePromise<void>;
-    /** Called when the encoder is no longer needed and its resources can be freed. */
-    abstract close(): MaybePromise<void>;
-}
-
-/**
- * An input track that was discarded (excluded) from a {@link Conversion} alongside the discard reason.
- * @group Conversion
- * @public
- */
-export declare type DiscardedTrack = {
-    /** The track that was discarded. */
-    track: InputTrack;
-    /**
-     * The reason for discarding the track.
-     *
-     * - `'discarded_by_user'`: You discarded this track by setting `discard: true`.
-     * - `'max_track_count_reached'`: The output had no more room for another track.
-     * - `'max_track_count_of_type_reached'`: The output had no more room for another track of this type, or the output
-     * doesn't support this track type at all.
-     * - `'unknown_source_codec'`: We don't know the codec of the input track and therefore don't know what to do
-     * with it.
-     * - `'undecodable_source_codec'`: The input track's codec is known, but we are unable to decode it.
-     * - `'no_encodable_target_codec'`: We can't find a codec that we are able to encode and that can be contained
-     * within the output format. This reason can be hit if the environment doesn't support the necessary encoders, or if
-     * you requested a codec that cannot be contained within the output format.
-     */
-    reason: 'discarded_by_user' | 'max_track_count_reached' | 'max_track_count_of_type_reached' | 'unknown_source_codec' | 'undecodable_source_codec' | 'no_encodable_target_codec';
-};
-
-/**
- * The most basic audio source; can be used to directly pipe encoded packets into the output file.
- * @group Media sources
- * @public
- */
-export declare class EncodedAudioPacketSource extends AudioSource {
-    /** Creates a new {@link EncodedAudioPacketSource} whose packets are encoded using `codec`. */
-    constructor(codec: AudioCodec);
-    /**
-     * Adds an encoded packet to the output audio track. Packets must be added in *decode order*.
-     *
-     * @param meta - Additional metadata from the encoder. You should pass this for the first call, including a valid
-     * decoder config.
-     *
-     * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
-     * to respect writer and encoder backpressure.
-     */
-    add(packet: EncodedPacket, meta?: EncodedAudioChunkMetadata): Promise<void>;
-}
-
-/**
- * Represents an encoded chunk of media. Mainly used as an expressive wrapper around WebCodecs API's
- * [`EncodedVideoChunk`](https://developer.mozilla.org/en-US/docs/Web/API/EncodedVideoChunk) and
- * [`EncodedAudioChunk`](https://developer.mozilla.org/en-US/docs/Web/API/EncodedAudioChunk), but can also be used
- * standalone.
- * @group Packets
- * @public
- */
-export declare class EncodedPacket {
-    /** The encoded data of this packet. */
-    readonly data: Uint8Array;
-    /** The type of this packet. */
-    readonly type: PacketType;
-    /**
-     * The presentation timestamp of this packet in seconds. May be negative. Samples with negative end timestamps
-     * should not be presented.
-     */
-    readonly timestamp: number;
-    /** The duration of this packet in seconds. */
-    readonly duration: number;
-    /**
-     * The sequence number indicates the decode order of the packets. Packet A  must be decoded before packet B if A
-     * has a lower sequence number than B. If two packets have the same sequence number, they are the same packet.
-     * Otherwise, sequence numbers are arbitrary and are not guaranteed to have any meaning besides their relative
-     * ordering. Negative sequence numbers mean the sequence number is undefined.
-     */
-    readonly sequenceNumber: number;
-    /**
-     * The actual byte length of the data in this packet. This field is useful for metadata-only packets where the
-     * `data` field contains no bytes.
-     */
-    readonly byteLength: number;
-    /** Additional data carried with this packet. */
-    readonly sideData: EncodedPacketSideData;
-    /** Creates a new {@link EncodedPacket} from raw bytes and timing information. */
-    constructor(
-    /** The encoded data of this packet. */
-    data: Uint8Array, 
-    /** The type of this packet. */
-    type: PacketType, 
-    /**
-     * The presentation timestamp of this packet in seconds. May be negative. Samples with negative end timestamps
-     * should not be presented.
-     */
-    timestamp: number, 
-    /** The duration of this packet in seconds. */
-    duration: number, 
-    /**
-     * The sequence number indicates the decode order of the packets. Packet A  must be decoded before packet B if A
-     * has a lower sequence number than B. If two packets have the same sequence number, they are the same packet.
-     * Otherwise, sequence numbers are arbitrary and are not guaranteed to have any meaning besides their relative
-     * ordering. Negative sequence numbers mean the sequence number is undefined.
-     */
-    sequenceNumber?: number, byteLength?: number, sideData?: EncodedPacketSideData);
-    /**
-     * If this packet is a metadata-only packet. Metadata-only packets don't contain their packet data. They are the
-     * result of retrieving packets with {@link PacketRetrievalOptions.metadataOnly} set to `true`.
-     */
-    get isMetadataOnly(): boolean;
-    /** The timestamp of this packet in microseconds. */
-    get microsecondTimestamp(): number;
-    /** The duration of this packet in microseconds. */
-    get microsecondDuration(): number;
-    /** Converts this packet to an
-     * [`EncodedVideoChunk`](https://developer.mozilla.org/en-US/docs/Web/API/EncodedVideoChunk) for use with the
-     * WebCodecs API. */
-    toEncodedVideoChunk(): EncodedVideoChunk;
-    /**
-     * Converts this packet to an
-     * [`EncodedVideoChunk`](https://developer.mozilla.org/en-US/docs/Web/API/EncodedVideoChunk) for use with the
-     * WebCodecs API, using the alpha side data instead of the color data. Throws if no alpha side data is defined.
-     */
-    alphaToEncodedVideoChunk(type?: PacketType): EncodedVideoChunk;
-    /** Converts this packet to an
-     * [`EncodedAudioChunk`](https://developer.mozilla.org/en-US/docs/Web/API/EncodedAudioChunk) for use with the
-     * WebCodecs API. */
-    toEncodedAudioChunk(): EncodedAudioChunk;
-    /**
-     * Creates an {@link EncodedPacket} from an
-     * [`EncodedVideoChunk`](https://developer.mozilla.org/en-US/docs/Web/API/EncodedVideoChunk) or
-     * [`EncodedAudioChunk`](https://developer.mozilla.org/en-US/docs/Web/API/EncodedAudioChunk). This method is useful
-     * for converting chunks from the WebCodecs API to `EncodedPacket` instances.
-     */
-    static fromEncodedChunk(chunk: EncodedVideoChunk | EncodedAudioChunk, sideData?: EncodedPacketSideData): EncodedPacket;
-    /** Clones this packet while optionally updating timing information. */
-    clone(options?: {
-        /** The timestamp of the cloned packet in seconds. */
-        timestamp?: number;
-        /** The duration of the cloned packet in seconds. */
-        duration?: number;
-    }): EncodedPacket;
-}
-
-/**
- * Holds additional data accompanying an {@link EncodedPacket}.
- * @group Packets
- * @public
- */
-export declare type EncodedPacketSideData = {
-    /**
-     * An encoded alpha frame, encoded with the same codec as the packet. Typically used for transparent videos, where
-     * the alpha information is stored separately from the color information.
-     */
-    alpha?: Uint8Array;
-    /**
-     * The actual byte length of the alpha data. This field is useful for metadata-only packets where the
-     * `alpha` field contains no bytes.
-     */
-    alphaByteLength?: number;
-};
-
-/**
- * Sink for retrieving encoded packets from an input track.
- * @group Media sinks
- * @public
- */
-export declare class EncodedPacketSink {
-    /** Creates a new {@link EncodedPacketSink} for the given {@link InputTrack}. */
-    constructor(track: InputTrack);
-    /**
-     * Retrieves the track's first packet (in decode order), or null if it has no packets. The first packet is very
-     * likely to be a key packet.
-     */
-    getFirstPacket(options?: PacketRetrievalOptions): Promise<EncodedPacket | null>;
-    /**
-     * Retrieves the packet corresponding to the given timestamp, in seconds. More specifically, returns the last packet
-     * (in presentation order) with a start timestamp less than or equal to the given timestamp. This method can be
-     * used to retrieve a track's last packet using `getPacket(Infinity)`. The method returns null if the timestamp
-     * is before the first packet in the track.
-     *
-     * @param timestamp - The timestamp used for retrieval, in seconds.
-     */
-    getPacket(timestamp: number, options?: PacketRetrievalOptions): Promise<EncodedPacket | null>;
-    /**
-     * Retrieves the packet following the given packet (in decode order), or null if the given packet is the
-     * last packet.
-     */
-    getNextPacket(packet: EncodedPacket, options?: PacketRetrievalOptions): Promise<EncodedPacket | null>;
-    /**
-     * Retrieves the key packet corresponding to the given timestamp, in seconds. More specifically, returns the last
-     * key packet (in presentation order) with a start timestamp less than or equal to the given timestamp. A key packet
-     * is a packet that doesn't require previous packets to be decoded. This method can be used to retrieve a track's
-     * last key packet using `getKeyPacket(Infinity)`. The method returns null if the timestamp is before the first
-     * key packet in the track.
-     *
-     * To ensure that the returned packet is guaranteed to be a real key frame, enable `options.verifyKeyPackets`.
-     *
-     * @param timestamp - The timestamp used for retrieval, in seconds.
-     */
-    getKeyPacket(timestamp: number, options?: PacketRetrievalOptions): Promise<EncodedPacket | null>;
-    /**
-     * Retrieves the key packet following the given packet (in decode order), or null if the given packet is the last
-     * key packet.
-     *
-     * To ensure that the returned packet is guaranteed to be a real key frame, enable `options.verifyKeyPackets`.
-     */
-    getNextKeyPacket(packet: EncodedPacket, options?: PacketRetrievalOptions): Promise<EncodedPacket | null>;
-    /**
-     * Creates an async iterator that yields the packets in this track in decode order. To enable fast iteration, this
-     * method will intelligently preload packets based on the speed of the consumer.
-     *
-     * @param startPacket - (optional) The packet from which iteration should begin. This packet will also be yielded.
-     * @param endTimestamp - (optional) The timestamp at which iteration should end. This packet will _not_ be yielded.
-     */
-    packets(startPacket?: EncodedPacket, endPacket?: EncodedPacket, options?: PacketRetrievalOptions): AsyncGenerator<EncodedPacket, void, unknown>;
-}
-
-/**
- * The most basic video source; can be used to directly pipe encoded packets into the output file.
- * @group Media sources
- * @public
- */
-export declare class EncodedVideoPacketSource extends VideoSource {
-    /** Creates a new {@link EncodedVideoPacketSource} whose packets are encoded using `codec`. */
-    constructor(codec: VideoCodec);
-    /**
-     * Adds an encoded packet to the output video track. Packets must be added in *decode order*, while a packet's
-     * timestamp must be its *presentation timestamp*. B-frames are handled automatically.
-     *
-     * @param meta - Additional metadata from the encoder. You should pass this for the first call, including a valid
-     * decoder config.
-     *
-     * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
-     * to respect writer and encoder backpressure.
-     */
-    add(packet: EncodedPacket, meta?: EncodedVideoChunkMetadata): Promise<void>;
-}
-
-/**
- * A source backed by a path to a file. Intended for server-side usage in Node, Bun, or Deno.
- *
- * Make sure to call `.dispose()` on the corresponding {@link Input} when done to explicitly free the internal file
- * handle acquired by this source.
- * @group Input sources
- * @public
- */
-export declare class FilePathSource extends Source {
-    /** Creates a new {@link FilePathSource} backed by the file at the specified file path. */
-    constructor(filePath: string, options?: BlobSourceOptions);
-}
-
-/**
- * Options for {@link FilePathSource}.
- * @group Input sources
- * @public
- */
-export declare type FilePathSourceOptions = {
-    /** The maximum number of bytes the cache is allowed to hold in memory. Defaults to 8 MiB. */
-    maxCacheSize?: number;
-};
-
-/**
- * A target that writes to a file at the specified path. Intended for server-side usage in Node, Bun, or Deno.
- *
- * Writing is chunked by default. The internally held file handle will be closed when `.finalize()` or `.cancel()` are
- * called on the corresponding {@link Output}.
- * @group Output targets
- * @public
- */
-export declare class FilePathTarget extends Target {
-    /** Creates a new {@link FilePathTarget} that writes to the file at the specified file path. */
-    constructor(filePath: string, options?: FilePathTargetOptions);
-}
-
-/**
- * Options for {@link FilePathTarget}.
- * @group Output targets
- * @public
- */
-export declare type FilePathTargetOptions = StreamTargetOptions;
-
-/**
- * FLAC input format singleton.
- * @group Input formats
- * @public
- */
-export declare const FLAC: FlacInputFormat;
-
-/**
- * FLAC file format.
- *
- * Do not instantiate this class; use the {@link FLAC} singleton instead.
- *
- * @group Input formats
- * @public
- */
-export declare class FlacInputFormat extends InputFormat {
-    get name(): string;
-    get mimeType(): string;
-}
-
-/**
- * FLAC file format.
- * @group Output formats
- * @public
- */
-export declare class FlacOutputFormat extends OutputFormat {
-    /** Creates a new {@link FlacOutputFormat} configured with the specified `options`. */
-    constructor(options?: FlacOutputFormatOptions);
-    getSupportedTrackCounts(): TrackCountLimits;
-    get fileExtension(): string;
-    get mimeType(): string;
-    getSupportedCodecs(): MediaCodec[];
-    get supportsVideoRotationMetadata(): boolean;
-}
-
-/**
- * FLAC-specific output options.
- * @group Output formats
- * @public
- */
-export declare type FlacOutputFormatOptions = {
-    /**
-     * Will be called for each FLAC frame that is written.
-     *
-     * @param data - The raw bytes.
-     * @param position - The byte offset of the data in the file.
-     */
-    onFrame?: (data: Uint8Array, position: number) => unknown;
-};
-
-/**
- * Formats seconds to ASS/SSA timestamp format (H:MM:SS.cc).
- * @group Media sources
- * @public
- */
-export declare const formatAssTimestamp: (seconds: number) => string;
-
-/**
- * Formats subtitle cues back to ASS/SSA text format with header.
- * Properly inserts Dialogue/Comment lines within [Events] section.
- * @group Media sources
- * @public
- */
-export declare const formatCuesToAss: (cues: SubtitleCue[], header: string) => string;
-
-/**
- * Formats subtitle cues back to SRT text format.
- * @group Media sources
- * @public
- */
-export declare const formatCuesToSrt: (cues: SubtitleCue[]) => string;
-
-/**
- * Formats subtitle cues back to WebVTT text format.
- * @group Media sources
- * @public
- */
-export declare const formatCuesToWebVTT: (cues: SubtitleCue[], preamble?: string) => string;
-
-/**
- * Formats seconds to SRT timestamp format (HH:MM:SS,mmm).
- * @group Media sources
- * @public
- */
-export declare const formatSrtTimestamp: (seconds: number) => string;
-
-/**
- * Returns the list of all audio codecs that can be encoded by the browser.
- * @group Encoding
- * @public
- */
-export declare const getEncodableAudioCodecs: (checkedCodecs?: AudioCodec[], options?: {
-    numberOfChannels?: number;
-    sampleRate?: number;
-    bitrate?: number | Quality;
-}) => Promise<AudioCodec[]>;
-
-/**
- * Returns the list of all media codecs that can be encoded by the browser.
- * @group Encoding
- * @public
- */
-export declare const getEncodableCodecs: () => Promise<MediaCodec[]>;
-
-/**
- * Returns the list of all subtitle codecs that can be encoded by the browser.
- * @group Encoding
- * @public
- */
-export declare const getEncodableSubtitleCodecs: (checkedCodecs?: SubtitleCodec[]) => Promise<SubtitleCodec[]>;
-
-/**
- * Returns the list of all video codecs that can be encoded by the browser.
- * @group Encoding
- * @public
- */
-export declare const getEncodableVideoCodecs: (checkedCodecs?: VideoCodec[], options?: {
-    width?: number;
-    height?: number;
-    bitrate?: number | Quality;
-}) => Promise<VideoCodec[]>;
-
-/**
- * Returns the first audio codec from the given list that can be encoded by the browser.
- * @group Encoding
- * @public
- */
-export declare const getFirstEncodableAudioCodec: (checkedCodecs: AudioCodec[], options?: {
-    numberOfChannels?: number;
-    sampleRate?: number;
-    bitrate?: number | Quality;
-}) => Promise<AudioCodec | null>;
-
-/**
- * Returns the first subtitle codec from the given list that can be encoded by the browser.
- * @group Encoding
- * @public
- */
-export declare const getFirstEncodableSubtitleCodec: (checkedCodecs: SubtitleCodec[]) => Promise<SubtitleCodec | null>;
-
-/**
- * Returns the first video codec from the given list that can be encoded by the browser.
- * @group Encoding
- * @public
- */
-export declare const getFirstEncodableVideoCodec: (checkedCodecs: VideoCodec[], options?: {
-    width?: number;
-    height?: number;
-    bitrate?: number | Quality;
-}) => Promise<VideoCodec | null>;
-
-/**
- * Specifies an inclusive range of integers.
- * @group Miscellaneous
- * @public
- */
-export declare type InclusiveIntegerRange = {
-    /** The integer cannot be less than this. */
-    min: number;
-    /** The integer cannot be greater than this. */
-    max: number;
-};
-
-/**
- * Represents an input media file. This is the root object from which all media read operations start.
- * @group Input files & tracks
- * @public
- */
-export declare class Input<S extends Source = Source> implements Disposable {
-    /** True if the input has been disposed. */
-    get disposed(): boolean;
-    /**
-     * Creates a new input file from the specified options. No reading operations will be performed until methods are
-     * called on this instance.
-     */
-    constructor(options: InputOptions<S>);
-    /**
-     * Returns the source from which this input file reads its data. This is the same source that was passed to the
-     * constructor.
-     */
-    get source(): S;
-    /**
-     * Returns the format of the input file. You can compare this result directly to the {@link InputFormat} singletons
-     * or use `instanceof` checks for subset-aware logic (for example, `format instanceof MatroskaInputFormat` is true
-     * for both MKV and WebM).
-     */
-    getFormat(): Promise<InputFormat>;
-    /**
-     * Computes the duration of the input file, in seconds. More precisely, returns the largest end timestamp among
-     * all tracks.
-     */
-    computeDuration(): Promise<number>;
-    /** Returns the list of all tracks of this input file. */
-    getTracks(): Promise<InputTrack[]>;
-    /** Returns the list of all video tracks of this input file. */
-    getVideoTracks(): Promise<InputVideoTrack[]>;
-    /** Returns the list of all audio tracks of this input file. */
-    getAudioTracks(): Promise<InputAudioTrack[]>;
-    /** Returns the list of all subtitle tracks of this input file. */
-    getSubtitleTracks(): Promise<InputSubtitleTrack[]>;
-    /** Returns the primary video track of this input file, or null if there are no video tracks. */
-    getPrimaryVideoTrack(): Promise<InputVideoTrack | null>;
-    /** Returns the primary audio track of this input file, or null if there are no audio tracks. */
-    getPrimaryAudioTrack(): Promise<InputAudioTrack | null>;
-    /**
-     * Returns the list of all subtitle tracks of this input file. This is a convenience property that calls
-     * {@link Input.getSubtitleTracks} and caches the result. Note that this property is a promise!
-     */
-    get subtitleTracks(): Promise<InputSubtitleTrack[]>;
-    /**
-     * Returns the list of all video tracks of this input file. This is a convenience property that calls
-     * {@link Input.getVideoTracks} and caches the result. Note that this property is a promise!
-     */
-    get videoTracks(): Promise<InputVideoTrack[]>;
-    /**
-     * Returns the list of all audio tracks of this input file. This is a convenience property that calls
-     * {@link Input.getAudioTracks} and caches the result. Note that this property is a promise!
-     */
-    get audioTracks(): Promise<InputAudioTrack[]>;
-    /** Returns the full MIME type of this input file, including track codecs. */
-    getMimeType(): Promise<string>;
-    /**
-     * Returns descriptive metadata tags about the media file, such as title, author, date, cover art, or other
-     * attached files.
-     */
-    getMetadataTags(): Promise<MetadataTags>;
-    /**
-     * Disposes this input and frees connected resources. When an input is disposed, ongoing read operations will be
-     * canceled, all future read operations will fail, any open decoders will be closed, and all ongoing media sink
-     * operations will be canceled. Disallowed and canceled operations will throw an {@link InputDisposedError}.
-     *
-     * You are expected not to use an input after disposing it. While some operations may still work, it is not
-     * specified and may change in any future update.
-     */
-    dispose(): void;
-    /**
-     * Calls `.dispose()` on the input, implementing the `Disposable` interface for use with
-     * JavaScript Explicit Resource Management features.
-     */
-    [Symbol.dispose](): void;
-}
-
-/**
- * Represents an audio track in an input file.
- * @group Input files & tracks
- * @public
- */
-export declare class InputAudioTrack extends InputTrack {
-    get type(): TrackType;
-    get codec(): AudioCodec | null;
-    /** The number of audio channels in the track. */
-    get numberOfChannels(): number;
-    /** The track's audio sample rate in hertz. */
-    get sampleRate(): number;
-    /**
-     * Returns the [decoder configuration](https://www.w3.org/TR/webcodecs/#audio-decoder-config) for decoding the
-     * track's packets using an [`AudioDecoder`](https://developer.mozilla.org/en-US/docs/Web/API/AudioDecoder). Returns
-     * null if the track's codec is unknown.
-     */
-    getDecoderConfig(): Promise<AudioDecoderConfig | null>;
-    getCodecParameterString(): Promise<string | null>;
-    canDecode(): Promise<boolean>;
-    determinePacketType(packet: EncodedPacket): Promise<PacketType | null>;
-}
-
-/**
- * Thrown when an operation was prevented because the corresponding {@link Input} has been disposed.
- * @group Input files & tracks
- * @public
- */
-export declare class InputDisposedError extends Error {
-    /** Creates a new {@link InputDisposedError}. */
-    constructor(message?: string);
-}
-
-/**
- * Base class representing an input media file format.
- * @group Input formats
- * @public
- */
-export declare abstract class InputFormat {
-    /** Returns the name of the input format. */
-    abstract get name(): string;
-    /** Returns the typical base MIME type of the input format. */
-    abstract get mimeType(): string;
-}
-
-/**
- * The options for creating an Input object.
- * @group Input files & tracks
- * @public
- */
-export declare type InputOptions<S extends Source = Source> = {
-    /** A list of supported formats. If the source file is not of one of these formats, then it cannot be read. */
-    formats: InputFormat[];
-    /** The source from which data will be read. */
-    source: S;
-};
-
-/**
- * Represents a subtitle track in an input file.
- * @group Input files & tracks
- * @public
- */
-export declare class InputSubtitleTrack extends InputTrack {
-    get type(): TrackType;
-    get codec(): SubtitleCodec | null;
-    /**
-     * Returns an async iterator that yields all subtitle cues in this track.
-     */
-    getCues(): AsyncGenerator<SubtitleCue>;
-    /**
-     * Exports all subtitle cues to text format. If targetFormat is specified,
-     * attempts to convert to that format (limited conversion support).
-     */
-    exportToText(targetFormat?: SubtitleCodec): Promise<string>;
-    getCodecParameterString(): Promise<string | null>;
-    canDecode(): Promise<boolean>;
-    determinePacketType(packet: EncodedPacket): Promise<PacketType | null>;
-}
-
-/**
- * Represents a media track in an input file.
- * @group Input files & tracks
- * @public
- */
-export declare abstract class InputTrack {
-    /** The input file this track belongs to. */
-    readonly input: Input;
-    /** The type of the track. */
-    abstract get type(): TrackType;
-    /** The codec of the track's packets. */
-    abstract get codec(): MediaCodec | null;
-    /** Returns the full codec parameter string for this track. */
-    abstract getCodecParameterString(): Promise<string | null>;
-    /** Checks if this track's packets can be decoded by the browser. */
-    abstract canDecode(): Promise<boolean>;
-    /**
-     * For a given packet of this track, this method determines the actual type of this packet (key/delta) by looking
-     * into its bitstream. Returns null if the type couldn't be determined.
-     */
-    abstract determinePacketType(packet: EncodedPacket): Promise<PacketType | null>;
-    /** Returns true if and only if this track is a video track. */
-    isVideoTrack(): this is InputVideoTrack;
-    /** Returns true if and only if this track is an audio track. */
-    isAudioTrack(): this is InputAudioTrack;
-    /** Returns true if and only if this track is a subtitle track. */
-    isSubtitleTrack(): this is InputSubtitleTrack;
-    /** The unique ID of this track in the input file. */
-    get id(): number;
-    /**
-     * The identifier of the codec used internally by the container. It is not homogenized by Mediabunny
-     * and depends entirely on the container format.
-     *
-     * This field can be used to determine the codec of a track in case Mediabunny doesn't know that codec.
-     *
-     * - For ISOBMFF files, this field returns the name of the Sample Description Box (e.g. `'avc1'`).
-     * - For Matroska files, this field returns the value of the `CodecID` element.
-     * - For WAVE files, this field returns the value of the format tag in the `'fmt '` chunk.
-     * - For ADTS files, this field contains the `MPEG-4 Audio Object Type`.
-     * - In all other cases, this field is `null`.
-     */
-    get internalCodecId(): string | number | Uint8Array<ArrayBufferLike> | null;
-    /**
-     * The ISO 639-2/T language code for this track. If the language is unknown, this field is `'und'` (undetermined).
-     */
-    get languageCode(): string;
-    /** A user-defined name for this track. */
-    get name(): string | null;
-    /**
-     * A positive number x such that all timestamps and durations of all packets of this track are
-     * integer multiples of 1/x.
-     */
-    get timeResolution(): number;
-    /** The track's disposition, i.e. information about its intended usage. */
-    get disposition(): TrackDisposition;
-    /**
-     * Returns the start timestamp of the first packet of this track, in seconds. While often near zero, this value
-     * may be positive or even negative. A negative starting timestamp means the track's timing has been offset. Samples
-     * with a negative timestamp should not be presented.
-     */
-    getFirstTimestamp(): Promise<number>;
-    /** Returns the end timestamp of the last packet of this track, in seconds. */
-    computeDuration(): Promise<number>;
-    /**
-     * Computes aggregate packet statistics for this track, such as average packet rate or bitrate.
-     *
-     * @param targetPacketCount - This optional parameter sets a target for how many packets this method must have
-     * looked at before it can return early; this means, you can use it to aggregate only a subset (prefix) of all
-     * packets. This is very useful for getting a great estimate of video frame rate without having to scan through the
-     * entire file.
-     */
-    computePacketStats(targetPacketCount?: number): Promise<PacketStats>;
-}
-
-/**
- * Represents a video track in an input file.
- * @group Input files & tracks
- * @public
- */
-export declare class InputVideoTrack extends InputTrack {
-    get type(): TrackType;
-    get codec(): VideoCodec | null;
-    /** The width in pixels of the track's coded samples, before any transformations or rotations. */
-    get codedWidth(): number;
-    /** The height in pixels of the track's coded samples, before any transformations or rotations. */
-    get codedHeight(): number;
-    /** The angle in degrees by which the track's frames should be rotated (clockwise). */
-    get rotation(): Rotation;
-    /** The width in pixels of the track's frames after rotation. */
-    get displayWidth(): number;
-    /** The height in pixels of the track's frames after rotation. */
-    get displayHeight(): number;
-    /** Returns the color space of the track's samples. */
-    getColorSpace(): Promise<VideoColorSpaceInit>;
-    /** If this method returns true, the track's samples use a high dynamic range (HDR). */
-    hasHighDynamicRange(): Promise<boolean>;
-    /** Checks if this track may contain transparent samples with alpha data. */
-    canBeTransparent(): Promise<boolean>;
-    /**
-     * Returns the [decoder configuration](https://www.w3.org/TR/webcodecs/#video-decoder-config) for decoding the
-     * track's packets using a [`VideoDecoder`](https://developer.mozilla.org/en-US/docs/Web/API/VideoDecoder). Returns
-     * null if the track's codec is unknown.
-     */
-    getDecoderConfig(): Promise<VideoDecoderConfig | null>;
-    getCodecParameterString(): Promise<string | null>;
-    canDecode(): Promise<boolean>;
-    determinePacketType(packet: EncodedPacket): Promise<PacketType | null>;
-}
-
-/**
- * Format representing files compatible with the ISO base media file format (ISOBMFF), like MP4 or MOV files.
- * @group Input formats
- * @public
- */
-export declare abstract class IsobmffInputFormat extends InputFormat {
-}
-
-/**
- * Format representing files compatible with the ISO base media file format (ISOBMFF), like MP4 or MOV files.
- * @group Output formats
- * @public
- */
-export declare abstract class IsobmffOutputFormat extends OutputFormat {
-    /** Internal constructor. */
-    constructor(options?: IsobmffOutputFormatOptions);
-    getSupportedTrackCounts(): TrackCountLimits;
-    get supportsVideoRotationMetadata(): boolean;
-}
-
-/**
- * ISOBMFF-specific output options.
- * @group Output formats
- * @public
- */
-export declare type IsobmffOutputFormatOptions = {
-    /**
-     * Controls the placement of metadata in the file. Placing metadata at the start of the file is known as "Fast
-     * Start", which results in better playback at the cost of more required processing or memory.
-     *
-     * Use `false` to disable Fast Start, placing the metadata at the end of the file. Fastest and uses the least
-     * memory.
-     *
-     * Use `'in-memory'` to produce a file with Fast Start by keeping all media chunks in memory until the file is
-     * finalized. This produces a high-quality and compact output at the cost of a more expensive finalization step and
-     * higher memory requirements. Data will be written monotonically (in order) when this option is set.
-     *
-     * Use `'reserve'` to reserve space at the start of the file into which the metadata will be written later.	This
-     * produces a file with Fast Start but requires knowledge about the expected length of the file beforehand. When
-     * using this option, you must set the {@link BaseTrackMetadata.maximumPacketCount} field in the track metadata
-     * for all tracks.
-     *
-     * Use `'fragmented'` to place metadata at the start of the file by creating a fragmented file (fMP4). In a
-     * fragmented file, chunks of media and their metadata are written to the file in "fragments", eliminating the need
-     * to put all metadata in one place. Fragmented files are useful for streaming contexts, as each fragment can be
-     * played individually without requiring knowledge of the other fragments. Furthermore, they remain lightweight to
-     * create even for very large files, as they don't require all media to be kept in memory. However, fragmented files
-     * are not as widely and wholly supported as regular MP4/MOV files. Data will be written monotonically (in order)
-     * when this option is set.
-     *
-     * When this field is not defined, either `false` or `'in-memory'` will be used, automatically determined based on
-     * the type of output target used.
-     */
-    fastStart?: false | 'in-memory' | 'reserve' | 'fragmented';
-    /**
-     * When using `fastStart: 'fragmented'`, this field controls the minimum duration of each fragment, in seconds.
-     * New fragments will only be created when the current fragment is longer than this value. Defaults to 1 second.
-     */
-    minimumFragmentDuration?: number;
-    /**
-     * The metadata format to use for writing metadata tags.
-     *
-     * - `'auto'` (default): Behaves like `'mdir'` for MP4 and like `'udta'` for QuickTime, matching FFmpeg's default
-     * behavior.
-     * - `'mdir'`: Write tags into `moov/udta/meta` using the 'mdir' handler format.
-     * - `'mdta'`: Write tags into `moov/udta/meta` using the 'mdta' handler format, equivalent to FFmpeg's
-     * `use_metadata_tags` flag. This allows for custom keys of arbitrary length.
-     * - `'udta'`: Write tags directly into `moov/udta`.
-     */
-    metadataFormat?: 'auto' | 'mdir' | 'mdta' | 'udta';
-    /**
-     * Will be called once the ftyp (File Type) box of the output file has been written.
-     *
-     * @param data - The raw bytes.
-     * @param position - The byte offset of the data in the file.
-     */
-    onFtyp?: (data: Uint8Array, position: number) => unknown;
-    /**
-     * Will be called once the moov (Movie) box of the output file has been written.
-     *
-     * @param data - The raw bytes.
-     * @param position - The byte offset of the data in the file.
-     */
-    onMoov?: (data: Uint8Array, position: number) => unknown;
-    /**
-     * Will be called for each finalized mdat (Media Data) box of the output file. Usage of this callback is not
-     * recommended when not using `fastStart: 'fragmented'`, as there will be one monolithic mdat box which might
-     * require large amounts of memory.
-     *
-     * @param data - The raw bytes.
-     * @param position - The byte offset of the data in the file.
-     */
-    onMdat?: (data: Uint8Array, position: number) => unknown;
-    /**
-     * Will be called for each finalized moof (Movie Fragment) box of the output file.
-     *
-     * @param data - The raw bytes.
-     * @param position - The byte offset of the data in the file.
-     * @param timestamp - The start timestamp of the fragment in seconds.
-     */
-    onMoof?: (data: Uint8Array, position: number, timestamp: number) => unknown;
-};
-
-/**
- * Matroska input format singleton.
- * @group Input formats
- * @public
- */
-export declare const MATROSKA: MatroskaInputFormat;
-
-/**
- * Matroska file format.
- *
- * Do not instantiate this class; use the {@link MATROSKA} singleton instead.
- *
- * @group Input formats
- * @public
- */
-export declare class MatroskaInputFormat extends InputFormat {
-    get name(): string;
-    get mimeType(): string;
-}
-
-/**
- * T or a promise that resolves to T.
- * @group Miscellaneous
- * @public
- */
-export declare type MaybePromise<T> = T | Promise<T>;
-
-/**
- * Union type of known media codecs.
- * @group Codecs
- * @public
- */
-export declare type MediaCodec = VideoCodec | AudioCodec | SubtitleCodec;
-
-/**
- * Base class for media sources. Media sources are used to add media samples to an output file.
- * @group Media sources
- * @public
- */
-declare abstract class MediaSource_2 {
-    /**
-     * Closes this source. This prevents future samples from being added and signals to the output file that no further
-     * samples will come in for this track. Calling `.close()` is optional but recommended after adding the
-     * last sample - for improved performance and reduced memory usage.
-     */
-    close(): void;
-}
-export { MediaSource_2 as MediaSource }
-
-/**
- * Audio source that encodes the data of a
- * [`MediaStreamAudioTrack`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack) and pipes it into the
- * output. This is useful for capturing live or real-time audio such as microphones or audio from other media elements.
- * Audio will automatically start being captured once the connected {@link Output} is started, and will keep being
- * captured until the {@link Output} is finalized or this source is closed.
- * @group Media sources
- * @public
- */
-export declare class MediaStreamAudioTrackSource extends AudioSource {
-    /** A promise that rejects upon any error within this source. This promise never resolves. */
-    get errorPromise(): Promise<void>;
-    /**
-     * Creates a new {@link MediaStreamAudioTrackSource} from a `MediaStreamAudioTrack`, which will pull audio samples
-     * from the stream in real time and encode them according to {@link AudioEncodingConfig}.
-     */
-    constructor(track: MediaStreamAudioTrack, encodingConfig: AudioEncodingConfig);
-}
-
-/**
- * Video source that encodes the frames of a
- * [`MediaStreamVideoTrack`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack) and pipes them into the
- * output. This is useful for capturing live or real-time data such as webcams or screen captures. Frames will
- * automatically start being captured once the connected {@link Output} is started, and will keep being captured until
- * the {@link Output} is finalized or this source is closed.
- * @group Media sources
- * @public
- */
-export declare class MediaStreamVideoTrackSource extends VideoSource {
-    /** A promise that rejects upon any error within this source. This promise never resolves. */
-    get errorPromise(): Promise<void>;
-    /**
-     * Creates a new {@link MediaStreamVideoTrackSource} from a
-     * [`MediaStreamVideoTrack`](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack), which will pull
-     * video samples from the stream in real time and encode them according to {@link VideoEncodingConfig}.
-     */
-    constructor(track: MediaStreamVideoTrack, encodingConfig: VideoEncodingConfig);
-}
-
-/**
- * Represents descriptive (non-technical) metadata about a media file, such as title, author, date, cover art, or other
- * attached files. Common tags are normalized by Mediabunny into a uniform format, while the `raw` field can be used to
- * directly read or write the underlying metadata tags (which differ by format).
- *
- * - For MP4/QuickTime files, the metadata refers to the data in `'moov'`-level `'udta'` and `'meta'` atoms.
- * - For WebM/Matroska files, the metadata refers to the Tags and Attachments elements whose target is 50 (MOVIE).
- * - For MP3 files, the metadata refers to the ID3v2 or ID3v1 tags.
- * - For Ogg files, there is no global metadata so instead, the metadata refers to the combined metadata of all tracks,
- * in Vorbis-style comment headers.
- * - For WAVE files, the metadata refers to the chunks within the RIFF INFO chunk.
- * - For ADTS files, there is no metadata.
- * - For FLAC files, the metadata lives in Vorbis style in the Vorbis comment block.
- *
- * @group Metadata tags
- * @public
- */
-export declare type MetadataTags = {
-    /** Title of the media (e.g. Gangnam Style, Titanic, etc.) */
-    title?: string;
-    /** Short description or subtitle of the media. */
-    description?: string;
-    /** Primary artist(s) or creator(s) of the work. */
-    artist?: string;
-    /** Album, collection, or compilation the media belongs to. */
-    album?: string;
-    /** Main credited artist for the album/collection as a whole. */
-    albumArtist?: string;
-    /** Position of this track within its album or collection (1-based). */
-    trackNumber?: number;
-    /** Total number of tracks in the album or collection. */
-    tracksTotal?: number;
-    /** Disc index if the release spans multiple discs (1-based). */
-    discNumber?: number;
-    /** Total number of discs in the release. */
-    discsTotal?: number;
-    /** Genre or category describing the media's style or content (e.g. Metal, Horror, etc.) */
-    genre?: string;
-    /** Release, recording or creation date of the media. */
-    date?: Date;
-    /** Full text lyrics or transcript associated with the media. */
-    lyrics?: string;
-    /** Freeform notes, remarks or commentary about the media. */
-    comment?: string;
-    /** Embedded images such as cover art, booklet scans, artwork or preview frames. */
-    images?: AttachedImage[];
-    /**
-     * The raw, underlying metadata tags.
-     *
-     * This field can be used for both reading and writing. When reading, it represents the original tags that were used
-     * to derive the normalized fields, and any additional metadata that Mediabunny doesn't understand. When writing, it
-     * can be used to set arbitrary metadata tags in the output file.
-     *
-     * The format of these tags differs per format:
-     * - MP4/QuickTime: By default, the keys refer to the names of the individual atoms in the `'ilst'` atom inside the
-     * `'meta'` atom, and the values are derived from the content of the `'data'` atom inside them. When a `'keys'` atom
-     * is also used, then the keys reflect the keys specified there (such as `'com.apple.quicktime.version'`).
-     * Additionally, any atoms within the `'udta'` atom are dumped into here, however with unknown internal format
-     * (`Uint8Array`).
-     * - WebM/Matroska: `SimpleTag` elements whose target is 50 (MOVIE), either containing string or `Uint8Array`
-     * values. Additionally, all attached files (such as font files) are included here, where the key corresponds to
-     * the FileUID and the value is an {@link AttachedFile}.
-     * - MP3: The ID3v2 tags, or a single `'TAG'` key with the contents of the ID3v1 tag.
-     * - Ogg: The key-value string pairs from the Vorbis-style comment header (see RFC 7845, Section 5.2).
-     * Additionally, the `'vendor'` key refers to the vendor string within this header.
-     * - WAVE: The individual metadata chunks within the RIFF INFO chunk. Values are always ISO 8859-1 strings.
-     * - FLAC: The key-value string pairs from the vorbis metadata block (see RFC 9639, Section D.2.3).
-     * Additionally, the `'vendor'` key refers to the vendor string within this header.
-     */
-    raw?: Record<string, string | Uint8Array | RichImageData | AttachedFile | null>;
-};
-
-/**
- * Matroska file format.
- *
- * Supports writing transparent video. For a video track to be marked as transparent, the first packet added must
- * contain alpha side data.
- *
- * @group Output formats
- * @public
- */
-export declare class MkvOutputFormat extends OutputFormat {
-    /** Creates a new {@link MkvOutputFormat} configured with the specified `options`. */
-    constructor(options?: MkvOutputFormatOptions);
-    getSupportedTrackCounts(): TrackCountLimits;
-    get fileExtension(): string;
-    get mimeType(): string;
-    getSupportedCodecs(): MediaCodec[];
-    get supportsVideoRotationMetadata(): boolean;
-}
-
-/**
- * Matroska-specific output options.
- * @group Output formats
- * @public
- */
-export declare type MkvOutputFormatOptions = {
-    /**
-     * Configures the output to only append new data at the end, useful for live-streaming the file as it's being
-     * created. When enabled, some features such as storing duration and seeking will be disabled or impacted, so don't
-     * use this option when you want to write out a clean file for later use.
-     */
-    appendOnly?: boolean;
-    /**
-     * This field controls the minimum duration of each Matroska cluster, in seconds. New clusters will only be created
-     * when the current cluster is longer than this value. Defaults to 1 second.
-     */
-    minimumClusterDuration?: number;
-    /**
-     * Will be called once the EBML header of the output file has been written.
-     *
-     * @param data - The raw bytes.
-     * @param position - The byte offset of the data in the file.
-     */
-    onEbmlHeader?: (data: Uint8Array, position: number) => void;
-    /**
-     * Will be called once the header part of the Matroska Segment element has been written. The header data includes
-     * the Segment element and everything inside it, up to (but excluding) the first Matroska Cluster.
-     *
-     * @param data - The raw bytes.
-     * @param position - The byte offset of the data in the file.
-     */
-    onSegmentHeader?: (data: Uint8Array, position: number) => unknown;
-    /**
-     * Will be called for each finalized Matroska Cluster of the output file.
-     *
-     * @param data - The raw bytes.
-     * @param position - The byte offset of the data in the file.
-     * @param timestamp - The start timestamp of the cluster in seconds.
-     */
-    onCluster?: (data: Uint8Array, position: number, timestamp: number) => unknown;
-};
-
-/**
- * QuickTime File Format (QTFF), often called MOV. Supports all video and audio codecs, but not subtitle codecs.
- * @group Output formats
- * @public
- */
-export declare class MovOutputFormat extends IsobmffOutputFormat {
-    /** Creates a new {@link MovOutputFormat} configured with the specified `options`. */
-    constructor(options?: IsobmffOutputFormatOptions);
-    get fileExtension(): string;
-    get mimeType(): string;
-    getSupportedCodecs(): MediaCodec[];
-}
-
-/**
- * MP3 input format singleton.
- * @group Input formats
- * @public
- */
-export declare const MP3: Mp3InputFormat;
-
-/**
- * MP3 file format.
- *
- * Do not instantiate this class; use the {@link MP3} singleton instead.
- *
- * @group Input formats
- * @public
- */
-export declare class Mp3InputFormat extends InputFormat {
-    get name(): string;
-    get mimeType(): string;
-}
-
-/**
- * MP3 file format.
- * @group Output formats
- * @public
- */
-export declare class Mp3OutputFormat extends OutputFormat {
-    /** Creates a new {@link Mp3OutputFormat} configured with the specified `options`. */
-    constructor(options?: Mp3OutputFormatOptions);
-    getSupportedTrackCounts(): TrackCountLimits;
-    get fileExtension(): string;
-    get mimeType(): string;
-    getSupportedCodecs(): MediaCodec[];
-    get supportsVideoRotationMetadata(): boolean;
-}
-
-/**
- * MP3-specific output options.
- * @group Output formats
- * @public
- */
-export declare type Mp3OutputFormatOptions = {
-    /**
-     * Controls whether the Xing header, which contains additional metadata as well as an index, is written to the start
-     * of the MP3 file. When disabled, the writing process becomes append-only. Defaults to `true`.
-     */
-    xingHeader?: boolean;
-    /**
-     * Will be called once the Xing metadata frame is finalized.
-     *
-     * @param data - The raw bytes.
-     * @param position - The byte offset of the data in the file.
-     */
-    onXingFrame?: (data: Uint8Array, position: number) => unknown;
-};
-
-/**
- * MP4 input format singleton.
- * @group Input formats
- * @public
- */
-export declare const MP4: Mp4InputFormat;
-
-/**
- * MPEG-4 Part 14 (MP4) file format.
- *
- * Do not instantiate this class; use the {@link MP4} singleton instead.
- *
- * @group Input formats
- * @public
- */
-export declare class Mp4InputFormat extends IsobmffInputFormat {
-    get name(): string;
-    get mimeType(): string;
-}
-
-/**
- * MPEG-4 Part 14 (MP4) file format. Supports most codecs.
- * @group Output formats
- * @public
- */
-export declare class Mp4OutputFormat extends IsobmffOutputFormat {
-    /** Creates a new {@link Mp4OutputFormat} configured with the specified `options`. */
-    constructor(options?: IsobmffOutputFormatOptions);
-    get fileExtension(): string;
-    get mimeType(): string;
-    getSupportedCodecs(): MediaCodec[];
-}
-
-/**
- * List of known compressed audio codecs, ordered by encoding preference.
- * @group Codecs
- * @public
- */
-export declare const NON_PCM_AUDIO_CODECS: readonly ["aac", "opus", "mp3", "vorbis", "flac"];
-
-/**
- * This target just discards all incoming data. It is useful for when you need an {@link Output} but extract data from
- * it differently, for example through format-specific callbacks (`onMoof`, `onMdat`, ...) or encoder events.
- * @group Output targets
- * @public
- */
-export declare class NullTarget extends Target {
-}
-
-/**
- * Ogg input format singleton.
- * @group Input formats
- * @public
- */
-export declare const OGG: OggInputFormat;
-
-/**
- * Ogg file format.
- *
- * Do not instantiate this class; use the {@link OGG} singleton instead.
- *
- * @group Input formats
- * @public
- */
-export declare class OggInputFormat extends InputFormat {
-    get name(): string;
-    get mimeType(): string;
-}
-
-/**
- * Ogg file format.
- * @group Output formats
- * @public
- */
-export declare class OggOutputFormat extends OutputFormat {
-    /** Creates a new {@link OggOutputFormat} configured with the specified `options`. */
-    constructor(options?: OggOutputFormatOptions);
-    getSupportedTrackCounts(): TrackCountLimits;
-    get fileExtension(): string;
-    get mimeType(): string;
-    getSupportedCodecs(): MediaCodec[];
-    get supportsVideoRotationMetadata(): boolean;
-}
-
-/**
- * Ogg-specific output options.
- * @group Output formats
- * @public
- */
-export declare type OggOutputFormatOptions = {
-    /**
-     * Will be called for each Ogg page that is written.
-     *
-     * @param data - The raw bytes.
-     * @param position - The byte offset of the data in the file.
-     * @param source - The {@link MediaSource} backing the page's logical bitstream (track).
-     */
-    onPage?: (data: Uint8Array, position: number, source: MediaSource_2) => unknown;
-};
-
-/**
- * Main class orchestrating the creation of a new media file.
- * @group Output files
- * @public
- */
-export declare class Output<F extends OutputFormat = OutputFormat, T extends Target = Target> {
-    /** The format of the output file. */
-    format: F;
-    /** The target to which the file will be written. */
-    target: T;
-    /** The current state of the output. */
-    state: 'pending' | 'started' | 'canceled' | 'finalizing' | 'finalized';
-    /**
-     * Creates a new instance of {@link Output} which can then be used to create a new media file according to the
-     * specified {@link OutputOptions}.
-     */
-    constructor(options: OutputOptions<F, T>);
-    /** Adds a video track to the output with the given source. Can only be called before the output is started. */
-    addVideoTrack(source: VideoSource, metadata?: VideoTrackMetadata): void;
-    /** Adds an audio track to the output with the given source. Can only be called before the output is started. */
-    addAudioTrack(source: AudioSource, metadata?: AudioTrackMetadata): void;
-    /** Adds a subtitle track to the output with the given source. Can only be called before the output is started. */
-    addSubtitleTrack(source: SubtitleSource, metadata?: SubtitleTrackMetadata): void;
-    /**
-     * Sets descriptive metadata tags about the media file, such as title, author, date, or cover art. When called
-     * multiple times, only the metadata from the last call will be used.
-     *
-     * Can only be called before the output is started.
-     */
-    setMetadataTags(tags: MetadataTags): void;
-    /**
-     * Starts the creation of the output file. This method should be called after all tracks have been added. Only after
-     * the output has started can media samples be added to the tracks.
-     *
-     * @returns A promise that resolves when the output has successfully started and is ready to receive media samples.
-     */
-    start(): Promise<void>;
-    /**
-     * Resolves with the full MIME type of the output file, including track codecs.
-     *
-     * The returned promise will resolve only once the precise codec strings of all tracks are known.
-     */
-    getMimeType(): Promise<string>;
-    /**
-     * Cancels the creation of the output file, releasing internal resources like encoders and preventing further
-     * samples from being added.
-     *
-     * @returns A promise that resolves once all internal resources have been released.
-     */
-    cancel(): Promise<void>;
-    /**
-     * Finalizes the output file. This method must be called after all media samples across all tracks have been added.
-     * Once the Promise returned by this method completes, the output file is ready.
-     */
-    finalize(): Promise<void>;
-}
-
-/**
- * Base class representing an output media file format.
- * @group Output formats
- * @public
- */
-export declare abstract class OutputFormat {
-    /** The file extension used by this output format, beginning with a dot. */
-    abstract get fileExtension(): string;
-    /** The base MIME type of the output format. */
-    abstract get mimeType(): string;
-    /** Returns a list of media codecs that this output format can contain. */
-    abstract getSupportedCodecs(): MediaCodec[];
-    /** Returns the number of tracks that this output format supports. */
-    abstract getSupportedTrackCounts(): TrackCountLimits;
-    /** Whether this output format supports video rotation metadata. */
-    abstract get supportsVideoRotationMetadata(): boolean;
-    /** Returns a list of video codecs that this output format can contain. */
-    getSupportedVideoCodecs(): VideoCodec[];
-    /** Returns a list of audio codecs that this output format can contain. */
-    getSupportedAudioCodecs(): AudioCodec[];
-    /** Returns a list of subtitle codecs that this output format can contain. */
-    getSupportedSubtitleCodecs(): SubtitleCodec[];
-}
-
-/**
- * The options for creating an Output object.
- * @group Output files
- * @public
- */
-export declare type OutputOptions<F extends OutputFormat = OutputFormat, T extends Target = Target> = {
-    /** The format of the output file. */
-    format: F;
-    /** The target to which the file will be written. */
-    target: T;
-};
-
-/**
- * Additional options for controlling packet retrieval.
- * @group Media sinks
- * @public
- */
-export declare type PacketRetrievalOptions = {
-    /**
-     * When set to `true`, only packet metadata (like timestamp) will be retrieved - the actual packet data will not
-     * be loaded.
-     */
-    metadataOnly?: boolean;
-    /**
-     * When set to true, key packets will be verified upon retrieval by looking into the packet's bitstream.
-     * If not enabled, the packet types will be determined solely by what's stored in the containing file and may be
-     * incorrect, potentially leading to decoder errors. Since determining a packet's actual type requires looking into
-     * its data, this option cannot be enabled together with `metadataOnly`.
-     */
-    verifyKeyPackets?: boolean;
-};
-
-/**
- * Contains aggregate statistics about the encoded packets of a track.
- * @group Input files & tracks
- * @public
- */
-export declare type PacketStats = {
-    /** The total number of packets. */
-    packetCount: number;
-    /** The average number of packets per second. For video tracks, this will equal the average frame rate (FPS). */
-    averagePacketRate: number;
-    /** The average number of bits per second. */
-    averageBitrate: number;
-};
-
-/**
- * The type of a packet. Key packets can be decoded without previous packets, while delta packets depend on previous
- * packets.
- * @group Packets
- * @public
- */
-export declare type PacketType = 'key' | 'delta';
-
-/**
- * Parses an ASS/SSA timestamp string (H:MM:SS.cc) to seconds.
- * @group Media sources
- * @public
- */
-export declare const parseAssTimestamp: (timeString: string) => number;
-
-/**
- * Parses an SRT timestamp string (HH:MM:SS,mmm) to seconds.
- * @group Media sources
- * @public
- */
-export declare const parseSrtTimestamp: (timeString: string) => number;
-
-/**
- * List of known PCM (uncompressed) audio codecs, ordered by encoding preference.
- * @group Codecs
- * @public
- */
-export declare const PCM_AUDIO_CODECS: readonly ["pcm-s16", "pcm-s16be", "pcm-s24", "pcm-s24be", "pcm-s32", "pcm-s32be", "pcm-f32", "pcm-f32be", "pcm-f64", "pcm-f64be", "pcm-u8", "pcm-s8", "ulaw", "alaw"];
-
-/**
- * QuickTime File Format input format singleton.
- * @group Input formats
- * @public
- */
-export declare const QTFF: QuickTimeInputFormat;
-
-/**
- * Represents a subjective media quality level.
- * @group Encoding
- * @public
- */
-export declare class Quality {
-}
-
-/**
- * Represents a high media quality.
- * @group Encoding
- * @public
- */
-export declare const QUALITY_HIGH: Quality;
-
-/**
- * Represents a low media quality.
- * @group Encoding
- * @public
- */
-export declare const QUALITY_LOW: Quality;
-
-/**
- * Represents a medium media quality.
- * @group Encoding
- * @public
- */
-export declare const QUALITY_MEDIUM: Quality;
-
-/**
- * Represents a very high media quality.
- * @group Encoding
- * @public
- */
-export declare const QUALITY_VERY_HIGH: Quality;
-
-/**
- * Represents a very low media quality.
- * @group Encoding
- * @public
- */
-export declare const QUALITY_VERY_LOW: Quality;
-
-/**
- * QuickTime File Format (QTFF), often called MOV.
- *
- * Do not instantiate this class; use the {@link QTFF} singleton instead.
- *
- * @group Input formats
- * @public
- */
-export declare class QuickTimeInputFormat extends IsobmffInputFormat {
-    get name(): string;
-    get mimeType(): string;
-}
-
-/**
- * A source backed by a [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) of
- * `Uint8Array`, representing an append-only byte stream of unknown length. This is the source to use for incrementally
- * streaming in input files that are still being constructed and whose size we don't yet know, like for example the
- * output chunks of [MediaRecorder](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder).
- *
- * This source is *unsized*, meaning calls to `.getSize()` will throw and readers are more limited due to the
- * lack of random file access. You should only use this source with sequential access patterns, such as reading all
- * packets from start to end. This source does not work well with random access patterns unless you increase its
- * max cache size.
- *
- * @group Input sources
- * @public
- */
-export declare class ReadableStreamSource extends Source {
-    /** Creates a new {@link ReadableStreamSource} backed by the specified `ReadableStream<Uint8Array>`. */
-    constructor(stream: ReadableStream<Uint8Array>, options?: ReadableStreamSourceOptions);
-}
-
-/**
- * Options for {@link ReadableStreamSource}.
- * @group Input sources
- * @public
- */
-export declare type ReadableStreamSourceOptions = {
-    /** The maximum number of bytes the cache is allowed to hold in memory. Defaults to 16 MiB. */
-    maxCacheSize?: number;
-};
-
-/**
- * Registers a custom video or audio decoder. Registered decoders will automatically be used for decoding whenever
- * possible.
- * @group Custom coders
- * @public
- */
-export declare const registerDecoder: (decoder: typeof CustomVideoDecoder | typeof CustomAudioDecoder) => void;
-
-/**
- * Registers a custom video or audio encoder. Registered encoders will automatically be used for encoding whenever
- * possible.
- * @group Custom coders
- * @public
- */
-export declare const registerEncoder: (encoder: typeof CustomVideoEncoder | typeof CustomAudioEncoder) => void;
-
-/**
- * Image data with additional metadata.
- *
- * @group Metadata tags
- * @public
- */
-export declare class RichImageData {
-    /** The raw image data. */
-    data: Uint8Array;
-    /** An RFC 6838 MIME type (e.g. image/jpeg, image/png, etc.) */
-    mimeType: string;
-    /** Creates a new {@link RichImageData}. */
-    constructor(
-    /** The raw image data. */
-    data: Uint8Array, 
-    /** An RFC 6838 MIME type (e.g. image/jpeg, image/png, etc.) */
-    mimeType: string);
-}
-
-/**
- * Represents a clockwise rotation in degrees.
- * @group Miscellaneous
- * @public
- */
-export declare type Rotation = 0 | 90 | 180 | 270;
-
-/**
- * Sets all keys K of T to be required.
- * @group Miscellaneous
- * @public
- */
-export declare type SetRequired<T, K extends keyof T> = T & Required<Pick<T, K>>;
-
-/**
- * The source base class, representing a resource from which bytes can be read.
- * @group Input sources
- * @public
- */
-export declare abstract class Source {
-    /**
-     * Resolves with the total size of the file in bytes. This function is memoized, meaning only the first call
-     * will retrieve the size.
-     *
-     * Returns null if the source is unsized.
-     */
-    getSizeOrNull(): Promise<number | null>;
-    /**
-     * Resolves with the total size of the file in bytes. This function is memoized, meaning only the first call
-     * will retrieve the size.
-     *
-     * Throws an error if the source is unsized.
-     */
-    getSize(): Promise<number>;
-    /** Called each time data is retrieved from the source. Will be called with the retrieved range (end exclusive). */
-    onread: ((start: number, end: number) => unknown) | null;
-}
-
-/**
- * Splits ASS/SSA subtitle text into header (styles) and individual cues.
- * Preserves all sections including [Fonts], [Graphics], and Aegisub sections.
- * Aegisub sections are moved to the end to avoid breaking [Events].
- * @group Media sources
- * @public
- */
-export declare const splitAssIntoCues: (text: string) => {
-    header: string;
-    cues: SubtitleCue[];
-};
-
-/**
- * Splits SRT subtitle text into individual cues.
- * @group Media sources
- * @public
- */
-export declare const splitSrtIntoCues: (text: string) => SubtitleCue[];
-
-/**
- * A general-purpose, callback-driven source that can get its data from anywhere.
- * @group Input sources
- * @public
- */
-export declare class StreamSource extends Source {
-    /** Creates a new {@link StreamSource} whose behavior is specified by `options`.  */
-    constructor(options: StreamSourceOptions);
-}
-
-/**
- * Options for defining a {@link StreamSource}.
- * @group Input sources
- * @public
- */
-export declare type StreamSourceOptions = {
-    /**
-     * Called when the size of the entire file is requested. Must return or resolve to the size in bytes. This function
-     * is guaranteed to be called before `read`.
-     */
-    getSize: () => MaybePromise<number>;
-    /**
-     * Called when data is requested. Must return or resolve to the bytes from the specified byte range, or a stream
-     * that yields these bytes.
-     */
-    read: (start: number, end: number) => MaybePromise<Uint8Array | ReadableStream<Uint8Array>>;
-    /**
-     * Called when the {@link Input} driven by this source is disposed.
-     */
-    dispose?: () => unknown;
-    /** The maximum number of bytes the cache is allowed to hold in memory. Defaults to 8 MiB. */
-    maxCacheSize?: number;
-    /**
-     * Specifies the prefetch profile that the reader should use with this source. A prefetch profile specifies the
-     * pattern with which bytes outside of the requested range are preloaded to reduce latency for future reads.
-     *
-     * - `'none'` (default): No prefetching; only the data needed in the moment is requested.
-     * - `'fileSystem'`: File system-optimized prefetching: a small amount of data is prefetched bidirectionally,
-     * aligned with page boundaries.
-     * - `'network'`: Network-optimized prefetching, or more generally, prefetching optimized for any high-latency
-     * environment: tries to minimize the amount of read calls and aggressively prefetches data when sequential access
-     * patterns are detected.
-     */
-    prefetchProfile?: 'none' | 'fileSystem' | 'network';
-};
-
-/**
- * This target writes data to a [`WritableStream`](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream),
- * making it a general-purpose target for writing data anywhere. It is also compatible with
- * [`FileSystemWritableFileStream`](https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream) for
- * use with the [File System Access API](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API). The
- * `WritableStream` can also apply backpressure, which will propagate to the output and throttle the encoders.
- * @group Output targets
- * @public
- */
-export declare class StreamTarget extends Target {
-    /** Creates a new {@link StreamTarget} which writes to the specified `writable`. */
-    constructor(writable: WritableStream<StreamTargetChunk>, options?: StreamTargetOptions);
-}
-
-/**
- * A data chunk for {@link StreamTarget}.
- * @group Output targets
- * @public
- */
-export declare type StreamTargetChunk = {
-    /** The operation type. */
-    type: 'write';
-    /** The data to write. */
-    data: Uint8Array;
-    /** The byte offset in the output file at which to write the data. */
-    position: number;
-};
-
-/**
- * Options for {@link StreamTarget}.
- * @group Output targets
- * @public
- */
-export declare type StreamTargetOptions = {
-    /**
-     * When setting this to true, data created by the output will first be accumulated and only written out
-     * once it has reached sufficient size, using a default chunk size of 16 MiB. This is useful for reducing the total
-     * amount of writes, at the cost of latency.
-     */
-    chunked?: boolean;
-    /** When using `chunked: true`, this specifies the maximum size of each chunk. Defaults to 16 MiB. */
-    chunkSize?: number;
-};
-
-/**
- * List of known subtitle codecs, ordered by encoding preference.
- * @group Codecs
- * @public
- */
-export declare const SUBTITLE_CODECS: readonly ["webvtt", "tx3g", "ttml", "srt", "ass", "ssa"];
-
-/**
- * Union type of known subtitle codecs.
- * @group Codecs
- * @public
- */
-export declare type SubtitleCodec = typeof SUBTITLE_CODECS[number];
-
-/**
- * Subtitle configuration data.
- * @group Media sources
- * @public
- */
-export declare type SubtitleConfig = {
-    /** Format-specific description (e.g., WebVTT preamble, ASS/SSA header). */
-    description: string;
-};
-
-/**
- * Represents a single subtitle cue with timing and text.
- * @group Media sources
- * @public
- */
-export declare type SubtitleCue = {
-    /** When the subtitle should appear, in seconds. */
-    timestamp: number;
-    /** How long the subtitle should be displayed, in seconds. */
-    duration: number;
-    /** The subtitle text content. */
-    text: string;
-    /** Optional cue identifier. */
-    identifier?: string;
-    /** Optional format-specific settings (e.g., VTT positioning). */
-    settings?: string;
-    /** Optional notes or comments. */
-    notes?: string;
-};
-
-/**
- * Metadata associated with subtitle cues.
- * @group Media sources
- * @public
- */
-export declare type SubtitleMetadata = {
-    /** Optional subtitle configuration. */
-    config?: SubtitleConfig;
-};
-
-/**
- * Base class for subtitle sources - sources for subtitle tracks.
- * @group Media sources
- * @public
- */
-export declare abstract class SubtitleSource extends MediaSource_2 {
-    /** Internal constructor. */
-    constructor(codec: SubtitleCodec);
-}
-
-/**
- * Additional metadata for subtitle tracks.
- * @group Output files
- * @public
- */
-export declare type SubtitleTrackMetadata = BaseTrackMetadata & {};
-
-/**
- * Base class for targets, specifying where output files are written.
- * @group Output targets
- * @public
- */
-export declare abstract class Target {
-    /**
-     * Called each time data is written to the target. Will be called with the byte range into which data was written.
-     *
-     * Use this callback to track the size of the output file as it grows. But be warned, this function is chatty and
-     * gets called *extremely* often.
-     */
-    onwrite: ((start: number, end: number) => unknown) | null;
-}
-
-/**
- * This source can be used to add subtitles from a subtitle text file.
- * @group Media sources
- * @public
- */
-export declare class TextSubtitleSource extends SubtitleSource {
-    /** Creates a new {@link TextSubtitleSource} where added text chunks are in the specified `codec`. */
-    constructor(codec: SubtitleCodec);
-    /**
-     * Parses the subtitle text according to the specified codec and adds it to the output track. You don't have to
-     * add the entire subtitle file at once here; you can provide it in chunks.
-     *
-     * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
-     * to respect writer and encoder backpressure.
-     */
-    add(text: string): Promise<void>;
-}
-
-/**
- * Specifies the number of tracks (for each track type and in total) that an output format supports.
- * @group Output formats
- * @public
- */
-export declare type TrackCountLimits = {
-    [K in TrackType]: InclusiveIntegerRange;
-} & {
-    /** Specifies the overall allowed range of track counts for the output format. */
-    total: InclusiveIntegerRange;
-};
-
-/**
- * Specifies a track's disposition, i.e. information about its intended usage.
- * @public
- * @group Miscellaneous
- */
-export declare type TrackDisposition = {
-    /**
-     * Indicates that this track is eligible for automatic selection by a player; that it is the main track among other,
-     * non-default tracks of the same type.
-     */
-    default: boolean;
-    /**
-     * Indicates that players should always display this track by default, even if it goes against the user's default
-     * preferences. For example, a subtitle track only containing translations of foreign-language audio.
-     */
-    forced: boolean;
-    /** Indicates that this track is in the content's original language. */
-    original: boolean;
-    /** Indicates that this track contains commentary. */
-    commentary: boolean;
-    /** Indicates that this track is intended for hearing-impaired users. */
-    hearingImpaired: boolean;
-    /** Indicates that this track is intended for visually-impaired users. */
-    visuallyImpaired: boolean;
-};
-
-/**
- * Union type of all track types.
- * @group Miscellaneous
- * @public
- */
-export declare type TrackType = typeof ALL_TRACK_TYPES[number];
-
-/**
- * A source backed by a URL. This is useful for reading data from the network. Requests will be made using an optimized
- * reading and prefetching pattern to minimize request count and latency.
- * @group Input sources
- * @public
- */
-export declare class UrlSource extends Source {
-    /** Creates a new {@link UrlSource} backed by the resource at the specified URL. */
-    constructor(url: string | URL | Request, options?: UrlSourceOptions);
-}
-
-/**
- * Options for {@link UrlSource}.
- * @group Input sources
- * @public
- */
-export declare type UrlSourceOptions = {
-    /**
-     * The [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit) used by the Fetch API. Can be
-     * used to further control the requests, such as setting custom headers.
-     */
-    requestInit?: RequestInit;
-    /**
-     * A function that returns the delay (in seconds) before retrying a failed request. The function is called
-     * with the number of previous, unsuccessful attempts, as well as with the error with which the previous request
-     * failed. If the function returns `null`, no more retries will be made.
-     *
-     * By default, it uses an exponential backoff algorithm that never gives up unless
-     * a CORS error is suspected (`fetch()` did reject, `navigator.onLine` is true and origin is different)
-     */
-    getRetryDelay?: (previousAttempts: number, error: unknown, url: string | URL | Request) => number | null;
-    /** The maximum number of bytes the cache is allowed to hold in memory. Defaults to 64 MiB. */
-    maxCacheSize?: number;
-    /**
-     * A WHATWG-compatible fetch function. You can use this field to polyfill the `fetch` function, add missing
-     * features, or use a custom implementation.
-     */
-    fetchFn?: typeof fetch;
-};
-
-/**
- * List of known video codecs, ordered by encoding preference.
- * @group Codecs
- * @public
- */
-export declare const VIDEO_CODECS: readonly ["avc", "hevc", "vp9", "av1", "vp8"];
-
-/**
- * Union type of known video codecs.
- * @group Codecs
- * @public
- */
-export declare type VideoCodec = typeof VIDEO_CODECS[number];
-
-/**
- * Additional options that control audio encoding.
- * @group Encoding
- * @public
- */
-export declare type VideoEncodingAdditionalOptions = {
-    /**
-     * What to do with alpha data contained in the video samples.
-     *
-     * - `'discard'` (default): Only the samples' color data is kept; the video is opaque.
-     * - `'keep'`: The samples' alpha data is also encoded as side data. Make sure to pair this mode with a container
-     * format that supports transparency (such as WebM or Matroska).
-     */
-    alpha?: 'discard' | 'keep';
-    /** Configures the bitrate mode; defaults to `'variable'`. */
-    bitrateMode?: 'constant' | 'variable';
-    /**
-     * The latency mode used by the encoder; controls the performance-quality tradeoff.
-     *
-     * - `'quality'` (default): The encoder prioritizes quality over latency, and no frames can be dropped.
-     * - `'realtime'`: The encoder prioritizes low latency over quality, and may drop frames if the encoder becomes
-     * overloaded to keep up with real-time requirements.
-     */
-    latencyMode?: 'quality' | 'realtime';
-    /**
-     * The full codec string as specified in the WebCodecs Codec Registry. This string must match the codec
-     * specified in `codec`. When not set, a fitting codec string will be constructed automatically by the library.
-     */
-    fullCodecString?: string;
-    /**
-     * A hint that configures the hardware acceleration method of this codec. This is best left on `'no-preference'`,
-     * the default.
-     */
-    hardwareAcceleration?: 'no-preference' | 'prefer-hardware' | 'prefer-software';
-    /**
-     * An encoding scalability mode identifier as defined by
-     * [WebRTC-SVC](https://w3c.github.io/webrtc-svc/#scalabilitymodes*).
-     */
-    scalabilityMode?: string;
-    /**
-     * An encoding video content hint as defined by
-     * [mst-content-hint](https://w3c.github.io/mst-content-hint/#video-content-hints).
-     */
-    contentHint?: string;
-};
-
-/**
- * Configuration object that controls video encoding. Can be used to set codec, quality, and more.
- * @group Encoding
- * @public
- */
-export declare type VideoEncodingConfig = {
-    /** The video codec that should be used for encoding the video samples (frames). */
-    codec: VideoCodec;
-    /**
-     * The target bitrate for the encoded video, in bits per second. Alternatively, a subjective {@link Quality} can
-     * be provided.
-     */
-    bitrate: number | Quality;
-    /**
-     * The interval, in seconds, of how often frames are encoded as a key frame. The default is 5 seconds. Frequent key
-     * frames improve seeking behavior but increase file size. When using multiple video tracks, you should give them
-     * all the same key frame interval.
-     */
-    keyFrameInterval?: number;
-    /**
-     * Video frames may change size over time. This field controls the behavior in case this happens.
-     *
-     * - `'deny'` (default) will throw an error, requiring all frames to have the exact same dimensions.
-     * - `'passThrough'` will allow the change and directly pass the frame to the encoder.
-     * - `'fill'` will stretch the image to fill the entire original box, potentially altering aspect ratio.
-     * - `'contain'` will contain the entire image within the original box while preserving aspect ratio. This may lead
-     * to letterboxing.
-     * - `'cover'` will scale the image until the entire original box is filled, while preserving aspect ratio.
-     *
-     * The "original box" refers to the dimensions of the first encoded frame.
-     */
-    sizeChangeBehavior?: 'deny' | 'passThrough' | 'fill' | 'contain' | 'cover';
-    /** Called for each successfully encoded packet. Both the packet and the encoding metadata are passed. */
-    onEncodedPacket?: (packet: EncodedPacket, meta: EncodedVideoChunkMetadata | undefined) => unknown;
-    /**
-     * Called when the internal [encoder config](https://www.w3.org/TR/webcodecs/#video-encoder-config), as used by the
-     * WebCodecs API, is created.
-     */
-    onEncoderConfig?: (config: VideoEncoderConfig) => unknown;
-} & VideoEncodingAdditionalOptions;
-
-/**
- * Represents a raw, unencoded video sample (frame). Mainly used as an expressive wrapper around WebCodecs API's
- * [`VideoFrame`](https://developer.mozilla.org/en-US/docs/Web/API/VideoFrame), but can also be used standalone.
- * @group Samples
- * @public
- */
-export declare class VideoSample implements Disposable {
-    /**
-     * The internal pixel format in which the frame is stored.
-     * [See pixel formats](https://developer.mozilla.org/en-US/docs/Web/API/VideoFrame/format)
-     */
-    readonly format: VideoPixelFormat | null;
-    /** The width of the frame in pixels. */
-    readonly codedWidth: number;
-    /** The height of the frame in pixels. */
-    readonly codedHeight: number;
-    /** The rotation of the frame in degrees, clockwise. */
-    readonly rotation: Rotation;
-    /**
-     * The presentation timestamp of the frame in seconds. May be negative. Frames with negative end timestamps should
-     * not be presented.
-     */
-    readonly timestamp: number;
-    /** The duration of the frame in seconds. */
-    readonly duration: number;
-    /** The color space of the frame. */
-    readonly colorSpace: VideoColorSpace;
-    /** The width of the frame in pixels after rotation. */
-    get displayWidth(): number;
-    /** The height of the frame in pixels after rotation. */
-    get displayHeight(): number;
-    /** The presentation timestamp of the frame in microseconds. */
-    get microsecondTimestamp(): number;
-    /** The duration of the frame in microseconds. */
-    get microsecondDuration(): number;
-    /**
-     * Whether this sample uses a pixel format that can hold transparency data. Note that this doesn't necessarily mean
-     * that the sample is transparent.
-     */
-    get hasAlpha(): boolean | null;
-    /**
-     * Creates a new {@link VideoSample} from a
-     * [`VideoFrame`](https://developer.mozilla.org/en-US/docs/Web/API/VideoFrame). This is essentially a near zero-cost
-     * wrapper around `VideoFrame`. The sample's metadata is optionally refined using the data specified in `init`.
-     */
-    constructor(data: VideoFrame, init?: VideoSampleInit);
-    /**
-     * Creates a new {@link VideoSample} from a
-     * [`CanvasImageSource`](https://udn.realityripple.com/docs/Web/API/CanvasImageSource), similar to the
-     * [`VideoFrame`](https://developer.mozilla.org/en-US/docs/Web/API/VideoFrame) constructor. When `VideoFrame` is
-     * available, this is simply a wrapper around its constructor. If not, it will copy the source's image data to an
-     * internal canvas for later use.
-     */
-    constructor(data: CanvasImageSource, init: SetRequired<VideoSampleInit, 'timestamp'>);
-    /**
-     * Creates a new {@link VideoSample} from raw pixel data specified in `data`. Additional metadata must be provided
-     * in `init`.
-     */
-    constructor(data: AllowSharedBufferSource, init: SetRequired<VideoSampleInit, 'format' | 'codedWidth' | 'codedHeight' | 'timestamp'>);
-    /** Clones this video sample. */
-    clone(): VideoSample;
-    /**
-     * Closes this video sample, releasing held resources. Video samples should be closed as soon as they are not
-     * needed anymore.
-     */
-    close(): void;
-    /** Returns the number of bytes required to hold this video sample's pixel data. */
-    allocationSize(): number;
-    /** Copies this video sample's pixel data to an ArrayBuffer or ArrayBufferView. */
-    copyTo(destination: AllowSharedBufferSource): Promise<void>;
-    /**
-     * Converts this video sample to a VideoFrame for use with the WebCodecs API. The VideoFrame returned by this
-     * method *must* be closed separately from this video sample.
-     */
-    toVideoFrame(): VideoFrame;
-    /**
-     * Draws the video sample to a 2D canvas context. Rotation metadata will be taken into account.
-     *
-     * @param dx - The x-coordinate in the destination canvas at which to place the top-left corner of the source image.
-     * @param dy - The y-coordinate in the destination canvas at which to place the top-left corner of the source image.
-     * @param dWidth - The width in pixels with which to draw the image in the destination canvas.
-     * @param dHeight - The height in pixels with which to draw the image in the destination canvas.
-     */
-    draw(context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, dx: number, dy: number, dWidth?: number, dHeight?: number): void;
-    /**
-     * Draws the video sample to a 2D canvas context. Rotation metadata will be taken into account.
-     *
-     * @param sx - The x-coordinate of the top left corner of the sub-rectangle of the source image to draw into the
-     * destination context.
-     * @param sy - The y-coordinate of the top left corner of the sub-rectangle of the source image to draw into the
-     * destination context.
-     * @param sWidth - The width of the sub-rectangle of the source image to draw into the destination context.
-     * @param sHeight - The height of the sub-rectangle of the source image to draw into the destination context.
-     * @param dx - The x-coordinate in the destination canvas at which to place the top-left corner of the source image.
-     * @param dy - The y-coordinate in the destination canvas at which to place the top-left corner of the source image.
-     * @param dWidth - The width in pixels with which to draw the image in the destination canvas.
-     * @param dHeight - The height in pixels with which to draw the image in the destination canvas.
-     */
-    draw(context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, sx: number, sy: number, sWidth: number, sHeight: number, dx: number, dy: number, dWidth?: number, dHeight?: number): void;
-    /**
-     * Draws the sample in the middle of the canvas corresponding to the context with the specified fit behavior.
-     */
-    drawWithFit(context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, options: {
-        /**
-         * Controls the fitting algorithm.
-         *
-         * - `'fill'` will stretch the image to fill the entire box, potentially altering aspect ratio.
-         * - `'contain'` will contain the entire image within the box while preserving aspect ratio. This may lead to
-         * letterboxing.
-         * - `'cover'` will scale the image until the entire box is filled, while preserving aspect ratio.
-         */
-        fit: 'fill' | 'contain' | 'cover';
-        /** A way to override rotation. Defaults to the rotation of the sample. */
-        rotation?: Rotation;
-        /**
-         * Specifies the rectangular region of the video sample to crop to. The crop region will automatically be
-         * clamped to the dimensions of the video sample. Cropping is performed after rotation but before resizing.
-         */
-        crop?: CropRectangle;
-    }): void;
-    /**
-     * Converts this video sample to a
-     * [`CanvasImageSource`](https://udn.realityripple.com/docs/Web/API/CanvasImageSource) for drawing to a canvas.
-     *
-     * You must use the value returned by this method immediately, as any VideoFrame created internally will
-     * automatically be closed in the next microtask.
-     */
-    toCanvasImageSource(): VideoFrame | OffscreenCanvas;
-    /** Sets the rotation metadata of this video sample. */
-    setRotation(newRotation: Rotation): void;
-    /** Sets the presentation timestamp of this video sample, in seconds. */
-    setTimestamp(newTimestamp: number): void;
-    /** Sets the duration of this video sample, in seconds. */
-    setDuration(newDuration: number): void;
-    /** Calls `.close()`. */
-    [Symbol.dispose](): void;
-}
-
-/**
- * Metadata used for VideoSample initialization.
- * @group Samples
- * @public
- */
-export declare type VideoSampleInit = {
-    /**
-     * The internal pixel format in which the frame is stored.
-     * [See pixel formats](https://developer.mozilla.org/en-US/docs/Web/API/VideoFrame/format)
-     */
-    format?: VideoPixelFormat;
-    /** The width of the frame in pixels. */
-    codedWidth?: number;
-    /** The height of the frame in pixels. */
-    codedHeight?: number;
-    /** The rotation of the frame in degrees, clockwise. */
-    rotation?: Rotation;
-    /** The presentation timestamp of the frame in seconds. */
-    timestamp?: number;
-    /** The duration of the frame in seconds. */
-    duration?: number;
-    /** The color space of the frame. */
-    colorSpace?: VideoColorSpaceInit;
-};
-
-/**
- * A sink that retrieves decoded video samples (video frames) from a video track.
- * @group Media sinks
- * @public
- */
-export declare class VideoSampleSink extends BaseMediaSampleSink<VideoSample> {
-    /** Creates a new {@link VideoSampleSink} for the given {@link InputVideoTrack}. */
-    constructor(videoTrack: InputVideoTrack);
-    /**
-     * Retrieves the video sample (frame) corresponding to the given timestamp, in seconds. More specifically, returns
-     * the last video sample (in presentation order) with a start timestamp less than or equal to the given timestamp.
-     * Returns null if the timestamp is before the track's first timestamp.
-     *
-     * @param timestamp - The timestamp used for retrieval, in seconds.
-     */
-    getSample(timestamp: number): Promise<VideoSample | null>;
-    /**
-     * Creates an async iterator that yields the video samples (frames) of this track in presentation order. This method
-     * will intelligently pre-decode a few frames ahead to enable fast iteration.
-     *
-     * @param startTimestamp - The timestamp in seconds at which to start yielding samples (inclusive).
-     * @param endTimestamp - The timestamp in seconds at which to stop yielding samples (exclusive).
-     */
-    samples(startTimestamp?: number, endTimestamp?: number): AsyncGenerator<VideoSample, void, unknown>;
-    /**
-     * Creates an async iterator that yields a video sample (frame) for each timestamp in the argument. This method
-     * uses an optimized decoding pipeline if these timestamps are monotonically sorted, decoding each packet at most
-     * once, and is therefore more efficient than manually getting the sample for every timestamp. The iterator may
-     * yield null if no frame is available for a given timestamp.
-     *
-     * @param timestamps - An iterable or async iterable of timestamps in seconds.
-     */
-    samplesAtTimestamps(timestamps: AnyIterable<number>): AsyncGenerator<VideoSample | null, void, unknown>;
-}
-
-/**
- * This source can be used to add raw, unencoded video samples (frames) to an output video track. These frames will
- * automatically be encoded and then piped into the output.
- * @group Media sources
- * @public
- */
-export declare class VideoSampleSource extends VideoSource {
-    /**
-     * Creates a new {@link VideoSampleSource} whose samples are encoded according to the specified
-     * {@link VideoEncodingConfig}.
-     */
-    constructor(encodingConfig: VideoEncodingConfig);
-    /**
-     * Encodes a video sample (frame) and then adds it to the output.
-     *
-     * @returns A Promise that resolves once the output is ready to receive more samples. You should await this Promise
-     * to respect writer and encoder backpressure.
-     */
-    add(videoSample: VideoSample, encodeOptions?: VideoEncoderEncodeOptions): Promise<void>;
-}
-
-/**
- * Base class for video sources - sources for video tracks.
- * @group Media sources
- * @public
- */
-export declare abstract class VideoSource extends MediaSource_2 {
-    /** Internal constructor. */
-    constructor(codec: VideoCodec);
-}
-
-/**
- * Additional metadata for video tracks.
- * @group Output files
- * @public
- */
-export declare type VideoTrackMetadata = BaseTrackMetadata & {
-    /** The angle in degrees by which the track's frames should be rotated (clockwise). */
-    rotation?: Rotation;
-    /**
-     * The expected video frame rate in hertz. If set, all timestamps and durations of this track will be snapped to
-     * this frame rate. You should avoid adding more frames than the rate allows, as this will lead to multiple frames
-     * with the same timestamp.
-     */
-    frameRate?: number;
-};
-
-/**
- * WAVE input format singleton.
- * @group Input formats
- * @public
- */
-export declare const WAVE: WaveInputFormat;
-
-/**
- * WAVE file format, based on RIFF.
- *
- * Do not instantiate this class; use the {@link WAVE} singleton instead.
- *
- * @group Input formats
- * @public
- */
-export declare class WaveInputFormat extends InputFormat {
-    get name(): string;
-    get mimeType(): string;
-}
-
-/**
- * WAVE file format, based on RIFF.
- * @group Output formats
- * @public
- */
-export declare class WavOutputFormat extends OutputFormat {
-    /** Creates a new {@link WavOutputFormat} configured with the specified `options`. */
-    constructor(options?: WavOutputFormatOptions);
-    getSupportedTrackCounts(): TrackCountLimits;
-    get fileExtension(): string;
-    get mimeType(): string;
-    getSupportedCodecs(): MediaCodec[];
-    get supportsVideoRotationMetadata(): boolean;
-}
-
-/**
- * WAVE-specific output options.
- * @group Output formats
- * @public
- */
-export declare type WavOutputFormatOptions = {
-    /**
-     * When enabled, an RF64 file will be written, allowing for file sizes to exceed 4 GiB, which is otherwise not
-     * possible for regular WAVE files.
-     */
-    large?: boolean;
-    /**
-     * The metadata format to use for writing metadata tags.
-     *
-     * - `'info'` (default): Writes metadata into a RIFF INFO LIST chunk, the default way to contain metadata tags
-     * within WAVE. Only allows for a limited subset of tags to be written.
-     * - `'id3'`: Writes metadata into an ID3 chunk. Non-default, but used by many taggers in practice. Allows for a
-     * much larger and richer set of tags to be written.
-     */
-    metadataFormat?: 'info' | 'id3';
-    /**
-     * Will be called once the file header is written. The header consists of the RIFF header, the format chunk,
-     * metadata chunks, and the start of the data chunk (with a placeholder size of 0).
-     */
-    onHeader?: (data: Uint8Array, position: number) => unknown;
-};
-
-/**
- * WebM input format singleton.
- * @group Input formats
- * @public
- */
-export declare const WEBM: WebMInputFormat;
-
-/**
- * WebM file format, based on Matroska.
- *
- * Do not instantiate this class; use the {@link WEBM} singleton instead.
- *
- * @group Input formats
- * @public
- */
-export declare class WebMInputFormat extends MatroskaInputFormat {
-    get name(): string;
-    get mimeType(): string;
-}
-
-/**
- * WebM file format, based on Matroska.
- *
- * Supports writing transparent video. For a video track to be marked as transparent, the first packet added must
- * contain alpha side data.
- *
- * @group Output formats
- * @public
- */
-export declare class WebMOutputFormat extends MkvOutputFormat {
-    /** Creates a new {@link WebMOutputFormat} configured with the specified `options`. */
-    constructor(options?: MkvOutputFormatOptions);
-    getSupportedCodecs(): MediaCodec[];
-    get fileExtension(): string;
-    get mimeType(): string;
-}
-
-/**
- * WebM-specific output options.
- * @group Output formats
- * @public
- */
-export declare type WebMOutputFormatOptions = MkvOutputFormatOptions;
-
-/**
- * An AudioBuffer with additional timing information (timestamp & duration).
- * @group Media sinks
- * @public
- */
-export declare type WrappedAudioBuffer = {
-    /** An AudioBuffer. */
-    buffer: AudioBuffer;
-    /** The timestamp of the corresponding audio sample, in seconds. */
-    timestamp: number;
-    /** The duration of the corresponding audio sample, in seconds. */
-    duration: number;
-};
-
-/**
- * A canvas with additional timing information (timestamp & duration).
- * @group Media sinks
- * @public
- */
-export declare type WrappedCanvas = {
-    /** A canvas element or offscreen canvas. */
-    canvas: HTMLCanvasElement | OffscreenCanvas;
-    /** The timestamp of the corresponding video sample, in seconds. */
-    timestamp: number;
-    /** The duration of the corresponding video sample, in seconds. */
-    duration: number;
-};
-
-export { }
-export as namespace Mediabunny;