import { type InputAudioTrack } from 'mediabunny';
import { type ScheduleAudioNodeResult } from 'remotion';
import type { DelayPlaybackIfNotPremounting } from './delay-playback-if-not-premounting';
import { type AudioBufferSlice } from './make-iterator-with-priming';
import type { Nonce } from './nonce-manager';
import type { SharedAudioContextForMediaPlayer } from './shared-audio-context-for-media-player';
type ScheduleAudioNode = (node: AudioBufferSourceNode, mediaTimestamp: number, originalUnloopedMediaTimestamp: number, sourceOffsetInSeconds: number, sourceDurationInSeconds: number) => ScheduleAudioNodeResult;
export declare const MINIMUM_AUDIO_BUFFERING_TIME_SECONDS = 0.1;
export declare const hasEnoughAudioToStartPlayback: (bufferedDuration: number) => boolean;
export type AudioIteratorAnchor = {
    unloopedStartInSeconds: number;
    mediaStartInSeconds: number;
};
export declare const anchorToContinuousTime: ({ anchor, unloopedTimeInSeconds, playbackRate, }: {
    anchor: AudioIteratorAnchor;
    unloopedTimeInSeconds: number;
    playbackRate: number;
}) => number;
export declare const audioIteratorManager: ({ audioTrack, delayPlaybackHandleIfNotPremounting, sharedAudioContext, getSequenceEndTimestamp, getSequenceDurationInSeconds, getMediaEndTimestamp, getStartTime, initialMuted, initialVolume, toneFrequency, drawDebugOverlay, }: {
    audioTrack: InputAudioTrack;
    delayPlaybackHandleIfNotPremounting: () => DelayPlaybackIfNotPremounting;
    sharedAudioContext: SharedAudioContextForMediaPlayer;
    getSequenceEndTimestamp: () => number;
    getSequenceDurationInSeconds: () => number;
    getMediaEndTimestamp: () => number;
    getStartTime: () => number;
    initialMuted: boolean;
    initialVolume: number;
    toneFrequency: number;
    drawDebugOverlay: () => void;
}) => {
    startAudioIterator: ({ nonce, playbackRate, startFromSecond, unloopedStartFromSecond, scheduleAudioNode, getTargetTime, logLevel, loop, unscheduleAudioNode, getAudioContextCurrentTimeMockedInTest, }: {
        startFromSecond: number;
        unloopedStartFromSecond: number;
        nonce: Nonce;
        playbackRate: number;
        scheduleAudioNode: ScheduleAudioNode;
        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<AudioBufferSlice, void>>;
        isDestroyed: () => boolean;
        addQueuedAudioNode: (queuedNode: import("./audio/audio-preview-iterator").QueuedNode) => void;
        guessNextTimestamp: () => number;
        getQueuedPeriod: () => {
            from: number;
            until: number;
        } | null;
    } | null;
    getCurrentAnchor: () => 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: Nonce;
        playbackRate: number;
        localPlaybackRate: number;
        scheduleAudioNode: ScheduleAudioNode;
        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: ScheduleAudioNode;
        logLevel: "error" | "info" | "trace" | "verbose" | "warn";
        originalUnloopedMediaTimestamp: number;
        sourceOffsetInSeconds: number;
        sourceDurationInSeconds: number;
    }) => void;
    waitForNScheduledNodes: (n: number) => Promise<void>;
};
export type AudioIteratorManager = ReturnType<typeof audioIteratorManager>;
export {};