import { Decoder, Encoder, Frame, Packet } from './codecs';
import { ModuleType as FF, FFmpegModule, StdVector, StreamInfo } from './types/ffmpeg';
import { ChunkData, SourceInstance, TargetInstance, WriteChunkData } from "./types/graph";
export declare const vec2Array: <T>(vec: StdVector<T>) => T[];
export declare function getFFmpeg(): FFmpegModule;
declare class OutputIO {
    #private;
    get offset(): number;
    write(data: ChunkData): void;
    seek(pos: number): void;
    pullOutputs(): WriteChunkData[];
}
/**
 * Lazy loading Filterer, create on the fly. It dynamically accept frames with types.
 */
declare class Filterer {
    filterer?: FF['Filterer'];
    buffers: Frame[];
    src2args: {
        [k in string]?: string;
    };
    sink2args: {
        [k in string]?: string;
    };
    mediaTypes: {
        [k in string]?: 'audio' | 'video';
    };
    spec: string;
    constructor(inputs: string[], outputs: string[], mediaTypes: Filterer['mediaTypes'], spec: string);
    filter(frames: Frame[]): Promise<Frame[]>;
    flush(): Frame[];
    createFilterer(): void;
    close(): void;
}
/**
 * pushInputs (nodeId) -> Reader -> frames (streamId) -> Writer -> pullOutputs (nodeId)
 */
export declare type SourceReader = VideoSourceReader | FrameSourceReader;
export declare type TargetWriter = VideoTargetWriter | FrameTargetWriter;
declare class VideoSourceReader {
    #private;
    node: SourceInstance;
    demuxer: FF['Demuxer'];
    decoders: {
        [streamIndex in number]?: Decoder;
    };
    constructor(node: SourceInstance, demuxer: FF['Demuxer'], decorders: VideoSourceReader['decoders']);
    get inputEnd(): boolean;
    get currentTime(): number;
    get progress(): number | null;
    readPacket(): Promise<Packet>;
    readFrames(): Promise<Frame[]>;
    close(): void;
}
declare class FrameSourceReader {
    #private;
    node: SourceInstance;
    count: number;
    fps: number;
    streamInfo: StreamInfo;
    decoder?: Decoder;
    Packet: FFmpegModule['Packet'];
    constructor(node: SourceInstance, streamInfo: StreamInfo, useWebCodecs?: boolean);
    get inputEnd(): boolean;
    get currentTime(): number;
    get progress(): null;
    readFrames(): Promise<Frame[]>;
    close(): void;
}
declare class VideoTargetWriter {
    #private;
    node: TargetInstance;
    encoders: {
        [streamId: string]: Encoder;
    };
    targetStreamIndexes: {
        [streamId: string]: number;
    };
    muxer: FF['Muxer'];
    firstWrite: boolean;
    dataFilterers: {
        [streamId: string]: Filterer | undefined | null;
    };
    constructor(node: TargetInstance, muxer: FF['Muxer'], encoders: VideoTargetWriter['encoders'], outputIO: OutputIO, targetStreamIndexes: VideoTargetWriter['targetStreamIndexes']);
    writePacket(pkt: Packet, streamId: string): void;
    /**
     * @param frames last writing when frames=undefined
     */
    writeFrames(frames: Frame[]): Promise<void>;
    dataFormatFilter(frame: Frame): Promise<Frame>;
    writeEnd(): Promise<void>;
    pullOutputs(): WriteChunkData[];
    close(): void;
}
declare class FrameTargetWriter {
    #private;
    node: TargetInstance;
    encoder: Encoder;
    constructor(node: TargetInstance, streamInfo: StreamInfo);
    writeFrames(frames: Frame[]): Promise<void>;
    writeEnd(): Promise<void>;
    pullOutputs(): WriteChunkData[];
    close(): void;
}
export {};