/**
 * TimelineClock — pure time source.
 *
 * Advances time via internal RAF loop or external tick(delta).
 * Emits two events:
 * - 'tick' : every frame (~60fps)
 * - 'seek' : on explicit user actions (play/pause/seek/rate/loop)
 *
 * Does NOT know about playlists, segments, or data formats.
 */
export type TickEvent = {
    time: number;
    playing: boolean;
    rate: number;
};
export type SeekEvent = {
    time: number;
    source: 'seek' | 'play' | 'pause' | 'rate' | 'loop';
};
export type TimelineEventMap = {
    tick: TickEvent;
    seek: SeekEvent;
};
type Listener<T> = (event: T) => void;
export declare class TimelineClock {
    private _time;
    private _playing;
    private _rate;
    private _duration;
    private _loop;
    private _raf;
    private _lastFrame;
    private _listeners;
    constructor(duration?: number);
    get time(): number;
    get playing(): boolean;
    get rate(): number;
    get duration(): number;
    get loop(): boolean;
    play(): void;
    pause(): void;
    seek(time: number): void;
    setRate(rate: number): void;
    setLoop(v: boolean): void;
    /** Set duration to exactly `d`. */
    setDuration(d: number): void;
    /**
     * Extend duration to at least `d` (never shrink).
     * Safe for multiple engines sharing one clock — each calls
     * extendDuration(myDuration), clock keeps max(all).
     */
    extendDuration(d: number): void;
    /**
     * Advance time by `delta` seconds (scaled by rate).
     * Called internally by the RAF loop, or externally (e.g. R3F useFrame).
     * Delta is clamped to 100ms to prevent jumps after tab switches.
     */
    tick(delta: number): void;
    destroy(): void;
    on<K extends keyof TimelineEventMap>(event: K, fn: Listener<TimelineEventMap[K]>): () => void;
    private _startRAF;
    private _stopRAF;
    private _emitTick;
    private _emitSeek;
}
export {};
//# sourceMappingURL=timeline.d.ts.map