/**
 * @file Render Optimization Strategies
 * @description Advanced render optimization utilities including batching,
 * debouncing, priority scheduling, and render bailout mechanisms.
 * Designed for React 18+ concurrent features.
 *
 * Features:
 * - Render batching with priority
 * - State update coalescing
 * - Render bailout utilities
 * - Memoization helpers
 * - Virtual list optimization
 * - Component render tracking
 */
/**
 * Render priority levels
 */
export type RenderPriority = 'immediate' | 'high' | 'normal' | 'low' | 'idle';
/**
 * Render batch configuration
 */
export interface RenderBatchConfig {
    /** Maximum items per batch */
    batchSize: number;
    /** Delay between batches in ms */
    batchDelay: number;
    /** Priority for scheduling */
    priority: RenderPriority;
    /** Enable time slicing */
    timeSlicing: boolean;
    /** Time budget per frame in ms */
    frameBudget: number;
}
/**
 * Render statistics
 */
export interface RenderStats {
    totalRenders: number;
    skippedRenders: number;
    batchedUpdates: number;
    averageRenderTime: number;
    lastRenderTime: number;
    renderTimes: number[];
}
/**
 * Equality comparator function
 */
export type EqualityFn<T> = (prev: T, next: T) => boolean;
/**
 * State update function
 */
export type StateUpdater<T> = (prev: T) => T;
declare const PRIORITY_VALUES: Record<RenderPriority, number>;
declare const DEFAULT_BATCH_CONFIG: RenderBatchConfig;
/**
 * Manages batched render updates with priority scheduling
 */
export declare class RenderBatchManager<T = unknown> {
    private config;
    private pendingUpdates;
    private subscribers;
    private currentValues;
    private batchTimer;
    private isProcessing;
    private stats;
    constructor(config?: Partial<RenderBatchConfig>);
    /**
     * Schedule a state update
     */
    scheduleUpdate(key: string, update: StateUpdater<T>, priority?: RenderPriority): void;
    /**
     * Set a value directly (bypasses batching for immediate updates)
     */
    setImmediate(key: string, value: T): void;
    /**
     * Get current value
     */
    getValue(key: string): T | undefined;
    /**
     * Subscribe to value changes
     */
    subscribe(key: string, callback: (value: T) => void): () => void;
    /**
     * Get render statistics
     */
    getStats(): RenderStats;
    /**
     * Reset statistics
     */
    resetStats(): void;
    /**
     * Flush all pending updates immediately
     */
    flush(): void;
    private scheduleBatchProcess;
    private getHighestPriority;
    private getDelayForPriority;
    private processBatch;
    private processWithTimeSlicing;
    private processAllUpdates;
    private processKeyUpdates;
    private notifySubscribers;
    private updateRenderStats;
}
/**
 * Create a shallow equality comparator
 */
export declare function shallowEqual<T extends object>(objA: T, objB: T): boolean;
/**
 * Create a deep equality comparator
 */
export declare function deepEqual<T>(objA: T, objB: T): boolean;
/**
 * Create a memoized selector with custom equality
 */
export declare function createSelector<TInput, TOutput>(selector: (input: TInput) => TOutput, equalityFn?: EqualityFn<TOutput>): (input: TInput) => TOutput;
/**
 * Create a memoized function with LRU cache
 */
export declare function memoizeWithLRU<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => TResult, maxSize?: number, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TResult;
/**
 * Virtual list configuration
 */
export interface VirtualListConfig {
    /** Total number of items */
    itemCount: number;
    /** Height of each item in pixels */
    itemHeight: number;
    /** Container height in pixels */
    containerHeight: number;
    /** Number of items to render above/below visible area */
    overscan: number;
}
/**
 * Virtual list range
 */
export interface VirtualListRange {
    startIndex: number;
    endIndex: number;
    offsetTop: number;
    visibleCount: number;
}
/**
 * Calculate visible range for virtual list
 */
export declare function calculateVirtualListRange(scrollTop: number, config: VirtualListConfig): VirtualListRange;
/**
 * Create a stable item key generator
 */
export declare function createStableKeyGenerator<T>(getKey: (item: T, index: number) => string): (items: T[]) => Map<string, number>;
/**
 * Render tracking configuration
 */
export interface RenderTrackingConfig {
    /** Enable tracking */
    enabled: boolean;
    /** Log to console */
    logToConsole: boolean;
    /** Threshold for slow render warning in ms */
    slowRenderThreshold: number;
}
/**
 * Component render info
 */
export interface ComponentRenderInfo {
    componentName: string;
    renderCount: number;
    totalRenderTime: number;
    averageRenderTime: number;
    lastRenderTime: number;
    lastRenderReason: string | null;
}
/**
 * Configure render tracking
 */
export declare function configureRenderTracking(config: Partial<RenderTrackingConfig>): void;
/**
 * Track a component render
 */
export declare function trackRender(componentName: string, renderTime: number, reason?: string): void;
/**
 * Get render tracking info for a component
 */
export declare function getRenderInfo(componentName: string): ComponentRenderInfo | undefined;
/**
 * Get all render tracking info
 */
export declare function getAllRenderInfo(): Map<string, ComponentRenderInfo>;
/**
 * Clear render tracking data
 */
export declare function clearRenderTracking(): void;
/**
 * Get top slow-rendering components
 */
export declare function getSlowComponents(count?: number): ComponentRenderInfo[];
export { DEFAULT_BATCH_CONFIG, PRIORITY_VALUES };