import { DependencyList } from 'react';
/**
 * Render priority levels
 */
export type RenderPriority = 'immediate' | 'user-blocking' | 'normal' | 'low' | 'idle';
/**
 * Task status
 */
export type TaskStatus = 'pending' | 'running' | 'completed' | 'cancelled';
/**
 * Scheduled task
 */
export interface ScheduledTask {
    id: string;
    priority: RenderPriority;
    callback: () => void | Promise<void>;
    status: TaskStatus;
    deadline?: number;
    createdAt: number;
    startedAt?: number;
    completedAt?: number;
    estimatedDuration?: number;
}
/**
 * Scheduler statistics
 */
export interface SchedulerStats {
    totalTasks: number;
    completedTasks: number;
    cancelledTasks: number;
    averageWaitTime: number;
    averageExecutionTime: number;
    droppedFrames: number;
    frameTime: number;
    utilization: number;
}
/**
 * Frame budget configuration
 */
export interface FrameBudgetConfig {
    /** Target frames per second */
    targetFPS: number;
    /** Reserved time for browser work (ms) */
    browserReserve: number;
    /** Maximum time for a single task (ms) */
    maxTaskDuration: number;
    /** Enable adaptive budgeting */
    adaptive: boolean;
}
/**
 * Scheduler configuration
 */
export interface RenderSchedulerConfig {
    /** Frame budget settings */
    frameBudget?: Partial<FrameBudgetConfig>;
    /** Enable debug logging */
    debug?: boolean;
    /** Maximum queue size per priority */
    maxQueueSize?: number;
    /** Enable automatic cleanup */
    autoCleanup?: boolean;
    /** Cleanup interval (ms) */
    cleanupInterval?: number;
}
/**
 * Intelligent render scheduler with frame budget awareness
 */
export declare class RenderScheduler {
    private static instance;
    private config;
    private frameBudget;
    private queue;
    private isProcessing;
    private animationFrameId;
    private idleCallbackId;
    private completedTasks;
    private taskIdCounter;
    private cleanupIntervalId;
    constructor(config?: RenderSchedulerConfig);
    /**
     * Get singleton instance
     */
    static getInstance(config?: RenderSchedulerConfig): RenderScheduler;
    /**
     * Reset singleton (for testing)
     */
    static reset(): void;
    /**
     * Schedule a task
     */
    schedule(callback: () => void | Promise<void>, options?: {
        priority?: RenderPriority;
        deadline?: number;
        estimatedDuration?: number;
    }): string;
    /**
     * Cancel a scheduled task
     */
    cancel(taskId: string): boolean;
    /**
     * Schedule immediate work (runs synchronously if budget allows)
     */
    scheduleImmediate(callback: () => void): void;
    /**
     * Yield to main thread for responsiveness
     */
    yieldToMain(): Promise<void>;
    /**
     * Run work in chunks, yielding between chunks
     */
    runInChunks<T>(items: T[], processor: (item: T, index: number) => void, options?: {
        chunkSize?: number;
        yieldAfter?: number;
    }): Promise<void>;
    /**
     * Stop the scheduler
     */
    stop(): void;
    /**
     * Get scheduler statistics
     */
    getStats(): SchedulerStats;
    /**
     * Ensure processing is happening
     */
    private ensureProcessing;
    /**
     * Process the task queue
     */
    private processQueue;
    /**
     * Process immediate priority tasks
     */
    private processImmediateTasks;
    /**
     * Process tasks within frame budget
     */
    private processFrameTasks;
    /**
     * Process idle tasks during browser idle time
     */
    private processIdleTasks;
    /**
     * Execute a single task
     */
    private executeTask;
    /**
     * Start cleanup interval
     */
    private startCleanup;
    /**
     * Debug logging
     */
    private log;
}
/**
 * Hook for optimized rendering with frame budget awareness
 */
export declare function useOptimizedRender<T>(computeFn: () => T, deps: DependencyList, options?: {
    priority?: RenderPriority;
    defer?: boolean;
}): T | undefined;
/**
 * Hook for deferred rendering
 */
export declare function useDeferredRender(shouldDefer: boolean, delay?: number): {
    isDeferred: boolean;
    isDeferring: boolean;
};
/**
 * Hook for scheduling work with yield to main
 */
export declare function useScheduledWork(): {
    schedule: (callback: () => void | Promise<void>, priority?: RenderPriority) => string;
    cancel: (taskId: string) => void;
    yieldToMain: () => Promise<void>;
    runInChunks: <T>(items: T[], processor: (item: T, index: number) => void, options?: {
        chunkSize?: number;
        yieldAfter?: number;
    }) => Promise<void>;
};
/**
 * Hook for tracking render performance
 */
export declare function useRenderBudget(): {
    hasRemainingBudget: boolean;
    remainingTime: number;
    stats: SchedulerStats;
};
/**
 * Get the global render scheduler instance
 */
export declare function getRenderScheduler(config?: RenderSchedulerConfig): RenderScheduler;
/**
 * Reset the global scheduler (for testing)
 */
export declare function resetRenderScheduler(): void;
/**
 * Schedule work at a given priority
 */
export declare function scheduleWork(callback: () => void | Promise<void>, priority?: RenderPriority): string;
/**
 * Cancel scheduled work
 */
export declare function cancelWork(taskId: string): boolean;
/**
 * Yield to main thread
 */
export declare function yieldToMain(): Promise<void>;
/**
 * Run work in chunks with yielding
 */
export declare function runInChunks<T>(items: T[], processor: (item: T, index: number) => void, options?: {
    chunkSize?: number;
    yieldAfter?: number;
}): Promise<void>;
declare const _default: {
    RenderScheduler: typeof RenderScheduler;
    getRenderScheduler: typeof getRenderScheduler;
    resetRenderScheduler: typeof resetRenderScheduler;
    scheduleWork: typeof scheduleWork;
    cancelWork: typeof cancelWork;
    yieldToMain: typeof yieldToMain;
    runInChunks: typeof runInChunks;
    useOptimizedRender: typeof useOptimizedRender;
    useDeferredRender: typeof useDeferredRender;
    useScheduledWork: typeof useScheduledWork;
    useRenderBudget: typeof useRenderBudget;
};
export default _default;