export declare const drawPreviewOverlay: ({ context, audioTime, audioContextState, audioSyncAnchor, playing, audioIteratorManager, videoIteratorManager, playbackRate, }: {
    context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
    audioTime: number | null;
    audioContextState: AudioContextState | null;
    audioSyncAnchor: {
        value: number;
    } | null;
    playing: boolean;
    audioIteratorManager: {
        startAudioIterator: ({ nonce, playbackRate, startFromSecond, unloopedStartFromSecond, scheduleAudioNode, getTargetTime, logLevel, loop, unscheduleAudioNode, getAudioContextCurrentTimeMockedInTest, }: {
            startFromSecond: number;
            unloopedStartFromSecond: number;
            nonce: import("../nonce-manager").Nonce;
            playbackRate: number;
            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, sourceOffsetInSeconds: number, sourceDurationInSeconds: number) => import("remotion").ScheduleAudioNodeResult;
            getTargetTime: (mediaTimestamp: number, currentTime: number) => number | null;
            logLevel: "error" | "info" | "trace" | "verbose" | "warn";
            loop: boolean;
            unscheduleAudioNode: (node: AudioBufferSourceNode) => void;
            getAudioContextCurrentTimeMockedInTest: () => number;
        }) => void;
        getAudioBufferIterator: () => {
            destroy: () => void;
            getNextFn: () => Promise<IteratorResult<import("../make-iterator-with-priming").AudioBufferSlice, void>>;
            isDestroyed: () => boolean;
            addQueuedAudioNode: (queuedNode: import("../audio/audio-preview-iterator").QueuedNode) => void;
            guessNextTimestamp: () => number;
            getQueuedPeriod: () => {
                from: number;
                until: number;
            } | null;
        } | null;
        getCurrentAnchor: () => import("../audio-iterator-manager").AudioIteratorAnchor | null;
        destroyIterator: () => void;
        seek: ({ newTime, unloopedNewTime, nonce, playbackRate, localPlaybackRate, scheduleAudioNode, getTargetTime, logLevel, loop, trimBefore, trimAfter, sequenceOffset, sequenceDurationInFrames, fps, getAudioContextCurrentTimeMockedInTest, }: {
            newTime: number;
            unloopedNewTime: number;
            nonce: import("../nonce-manager").Nonce;
            playbackRate: number;
            localPlaybackRate: number;
            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, sourceOffsetInSeconds: number, sourceDurationInSeconds: number) => import("remotion").ScheduleAudioNodeResult;
            getTargetTime: (mediaTimestamp: number, currentTime: number) => number | null;
            logLevel: "error" | "info" | "trace" | "verbose" | "warn";
            loop: boolean;
            trimBefore: number | undefined;
            trimAfter: number | undefined;
            sequenceOffset: number;
            sequenceDurationInFrames: number;
            fps: number;
            getAudioContextCurrentTimeMockedInTest: () => number;
        }) => void;
        getAudioIteratorsCreated: () => number;
        getTotalAudioScheduledInSeconds: () => number;
        setMuted: (newMuted: boolean) => void;
        setVolume: (volume: number) => void;
        setToneFrequency: (newToneFrequency: number) => void;
        scheduleAudioChunk: ({ buffer, mediaTimestamp, originalUnloopedMediaTimestamp, sourceOffsetInSeconds, sourceDurationInSeconds, playbackRate, scheduleAudioNode, logLevel, }: {
            buffer: AudioBuffer;
            mediaTimestamp: number;
            playbackRate: number;
            scheduleAudioNode: (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, sourceOffsetInSeconds: number, sourceDurationInSeconds: number) => import("remotion").ScheduleAudioNodeResult;
            logLevel: "error" | "info" | "trace" | "verbose" | "warn";
            originalUnloopedMediaTimestamp: number;
            sourceOffsetInSeconds: number;
            sourceDurationInSeconds: number;
        }) => void;
        waitForNScheduledNodes: (n: number) => Promise<void>;
    } | null;
    videoIteratorManager: {
        startVideoIterator: (timeToSeek: number, nonce: import("../nonce-manager").Nonce) => Promise<void>;
        getVideoIteratorsCreated: () => number;
        seek: ({ newTime, nonce, fps, playbackRate, isPlaying, }: {
            newTime: number;
            nonce: import("../nonce-manager").Nonce;
            fps: number;
            playbackRate: number;
            isPlaying: boolean;
        }) => Promise<void>;
        destroy: () => void;
        getVideoFrameIterator: () => {
            destroy: () => void;
            initialFrame: import("mediabunny").WrappedCanvas | null;
            isDestroyed: () => boolean;
            tryToSatisfySeek: (time: number, options: {
                pendingFrameBehavior: "restart-iterator" | "wait";
                shouldContinue: () => boolean;
            }) => Promise<{
                type: "not-satisfied";
                reason: string;
            } | {
                type: "satisfied";
                frame: import("mediabunny").WrappedCanvas;
            }>;
        } | null;
        drawFrame: (frame: import("mediabunny").WrappedCanvas) => Promise<void>;
        redrawCurrentFrame: () => Promise<void>;
        getFramesRendered: () => number;
    } | null;
    playbackRate: number;
}) => void;