/**
 * AnimationScheduler - Coordinates animations, spinners, progress bars, and elapsed time
 * Provides frame-based animation updates and smooth transitions
 */
import { EventEmitter } from 'events';
export type AnimationType = 'spinner' | 'progress' | 'elapsed' | 'pulse' | 'transition';
export interface Animation {
    id: string;
    type: AnimationType;
    startTime: number;
    duration?: number;
    fps: number;
    frameCount: number;
    currentFrame: number;
    data?: unknown;
    easing?: EasingFunction;
    onFrame?: (animation: Animation) => void;
    onComplete?: (animation: Animation) => void;
}
export type EasingFunction = (t: number) => number;
export interface ProgressAnimation extends Animation {
    type: 'progress';
    data: {
        current: number;
        target: number;
        total: number;
        format?: (value: number, total: number) => string;
    };
}
export interface SpinnerAnimation extends Animation {
    type: 'spinner';
    data: {
        frames: string[];
        message?: string;
    };
}
export interface ElapsedAnimation extends Animation {
    type: 'elapsed';
    data: {
        startTime: number;
        format?: (elapsed: number) => string;
    };
}
export interface TransitionAnimation extends Animation {
    type: 'transition';
    data: {
        from: unknown;
        to: unknown;
        property: string;
    };
}
export declare class AnimationScheduler extends EventEmitter {
    private animations;
    private animationLoop;
    private targetFPS;
    private lastFrameTime;
    private frameInterval;
    private isRunning;
    private disposed;
    static readonly Easing: {
        linear: (t: number) => number;
        easeInQuad: (t: number) => number;
        easeOutQuad: (t: number) => number;
        easeInOutQuad: (t: number) => number;
        easeInCubic: (t: number) => number;
        easeOutCubic: (t: number) => number;
        easeInOutCubic: (t: number) => number;
        easeOutElastic: (t: number) => number;
    };
    static readonly SpinnerFrames: {
        dots: string[];
        dots2: string[];
        dots3: string[];
        line: string[];
        pipe: string[];
        simpleDots: string[];
        simpleDotsScrolling: string[];
        star: string[];
        hamburger: string[];
        growVertical: string[];
        growHorizontal: string[];
        balloon: string[];
        noise: string[];
        bounce: string[];
        boxBounce: string[];
        circle: string[];
        arc: string[];
        arrow: string[];
        bouncingBar: string[];
    };
    constructor(targetFPS?: number);
    /**
     * Create and register a spinner animation
     */
    createSpinner(id: string, message?: string, frames?: string[]): SpinnerAnimation;
    /**
     * Create and register a progress animation
     */
    createProgress(id: string, current: number, total: number, duration?: number): ProgressAnimation;
    /**
     * Update progress animation target
     */
    updateProgress(id: string, newTarget: number): void;
    /**
     * Create and register an elapsed time animation
     */
    createElapsed(id: string, startTime?: number): ElapsedAnimation;
    /**
     * Create and register a transition animation
     */
    createTransition(id: string, from: unknown, to: unknown, property: string, duration?: number, easing?: EasingFunction): TransitionAnimation;
    /**
     * Register an animation
     */
    register(animation: Animation): void;
    /**
     * Unregister an animation
     */
    unregister(id: string): void;
    /**
     * Start the animation loop
     */
    private start;
    /**
     * Stop the animation loop
     */
    private stop;
    /**
     * Main animation tick
     */
    private tick;
    /**
     * Update animation based on type
     */
    private updateAnimation;
    /**
     * Update spinner animation
     */
    private updateSpinner;
    /**
     * Update progress animation
     */
    private updateProgressAnimation;
    /**
     * Update elapsed time animation
     */
    private updateElapsed;
    /**
     * Update transition animation
     */
    private updateTransition;
    /**
     * Complete an animation
     */
    private completeAnimation;
    /**
     * Get current progress value with easing
     */
    private getCurrentProgressValue;
    /**
     * Format elapsed time
     */
    private formatElapsedTime;
    /**
     * Get animation by ID
     */
    getAnimation(id: string): Animation | undefined;
    /**
     * Get all active animations
     */
    getActiveAnimations(): Animation[];
    /**
     * Check if scheduler is running
     */
    isActive(): boolean;
    /**
     * Get target FPS
     */
    getTargetFPS(): number;
    /**
     * Set target FPS
     */
    setTargetFPS(fps: number): void;
    /**
     * Clear all animations
     */
    clearAll(): void;
    /**
     * Dispose of the scheduler
     */
    dispose(): void;
    /**
     * Check if the scheduler has been disposed
     */
    isDisposed(): boolean;
}
//# sourceMappingURL=AnimationScheduler.d.ts.map