/**
 * Advanced Performance Optimization
 *
 * Additional optimizations for extreme low-end devices and Android TV
 */
/**
 * Object Pool for DOM elements
 * Reuse elements instead of creating new ones
 */
export declare class DOMElementPool<T extends HTMLElement> {
    private pool;
    private createElement;
    private resetElement;
    private maxSize;
    constructor(createElement: () => T, resetElement?: (element: T) => void, maxSize?: number);
    /**
     * Get element from pool or create new one
     */
    acquire(): T;
    /**
     * Return element to pool for reuse
     */
    release(element: T): void;
    /**
     * Clear pool
     */
    clear(): void;
    /**
     * Get pool size
     */
    size(): number;
}
/**
 * Intersection Observer for lazy rendering
 * Only render visible elements
 */
export declare class LazyRenderer {
    private observer;
    private callbacks;
    constructor(options?: IntersectionObserverInit);
    /**
     * Observe element and call callback when visible
     */
    observe(element: Element, callback: () => void): void;
    /**
     * Stop observing element
     */
    unobserve(element: Element): void;
    /**
     * Disconnect observer
     */
    disconnect(): void;
}
/**
 * Memory-efficient WeakMap cache
 */
export declare class WeakCache<K extends object, V> {
    private cache;
    get(key: K): V | undefined;
    set(key: K, value: V): void;
    has(key: K): boolean;
    delete(key: K): boolean;
}
/**
 * Frame budget manager
 * Ensures operations don't exceed frame budget (16.67ms for 60fps)
 */
export declare class FrameBudgetManager {
    private frameStart;
    private readonly budget;
    constructor(fps?: number);
    /**
     * Start frame timing
     */
    startFrame(): void;
    /**
     * Check if we have time left in current frame
     */
    hasTimeLeft(): boolean;
    /**
     * Get remaining time in current frame
     */
    remainingTime(): number;
    /**
     * Execute tasks within frame budget
     */
    executeTasks<T>(tasks: (() => T)[], onComplete?: (results: T[]) => void): void;
}
/**
 * Virtual scrolling helper
 * Only render visible items
 */
export interface VirtualScrollOptions {
    itemHeight: number;
    containerHeight: number;
    overscan?: number;
}
export declare class VirtualScroller {
    private itemHeight;
    private containerHeight;
    private overscan;
    constructor(options: VirtualScrollOptions);
    /**
     * Calculate which items should be visible
     */
    getVisibleRange(scrollTop: number, totalItems: number): {
        start: number;
        end: number;
    };
    /**
     * Get total height needed for all items
     */
    getTotalHeight(totalItems: number): number;
    /**
     * Get offset for visible items
     */
    getOffsetTop(start: number): number;
}
/**
 * Adaptive quality manager
 * Reduce quality on slow devices
 */
export declare class AdaptiveQuality {
    private fps;
    private readonly maxSamples;
    private lastFrameTime;
    /**
     * Record frame time
     */
    recordFrame(): void;
    /**
     * Get average FPS
     */
    getAverageFPS(): number;
    /**
     * Check if performance is poor
     */
    isPoorPerformance(): boolean;
    /**
     * Get recommended quality level (0-1)
     */
    getQualityLevel(): number;
    /**
     * Reset measurements
     */
    reset(): void;
}
/**
 * Batch update scheduler
 * Group multiple updates into single frame
 */
export declare class BatchScheduler {
    private pending;
    private rafId;
    /**
     * Schedule function to run in next frame
     */
    schedule(fn: () => void): void;
    /**
     * Execute all pending functions
     */
    private flush;
    /**
     * Cancel all pending updates
     */
    cancel(): void;
    /**
     * Get number of pending updates
     */
    pendingCount(): number;
}
/**
 * Memory monitor
 * Track and limit memory usage
 */
export declare class MemoryMonitor {
    private readonly maxCacheSize;
    private cache;
    constructor(maxCacheSize?: number);
    /**
     * Add item to cache
     */
    set(key: string, value: any): void;
    /**
     * Get item from cache
     */
    get(key: string): any;
    /**
     * Clear cache
     */
    clear(): void;
    /**
     * Get current memory usage (if available)
     */
    getMemoryUsage(): number | null;
    /**
     * Get memory limit (if available)
     */
    getMemoryLimit(): number | null;
    /**
     * Get memory usage percentage
     */
    getMemoryUsagePercent(): number | null;
    /**
     * Check if memory usage is high
     */
    isMemoryHigh(): boolean;
}