/**
 * Performance Utilities
 * Optimization utilities for charts and data processing
 */
import React from 'react';
export declare function useDebounce<T>(value: T, delay: number): T;
export declare function useThrottle<T extends (...args: any[]) => any>(callback: T, delay: number): T;
export interface VirtualScrolling {
    containerHeight: number;
    itemHeight: number;
    itemCount: number;
    overscan?: number;
}
export interface VirtualScrollResult {
    startIndex: number;
    endIndex: number;
    visibleItems: number[];
    containerProps: {
        style: React.CSSProperties;
        onScroll: (event: React.UIEvent<HTMLDivElement>) => void;
    };
    itemProps: (index: number) => {
        style: React.CSSProperties;
        key: string | number;
    };
}
export declare function useVirtualScrolling({ containerHeight, itemHeight, itemCount, overscan }: VirtualScrolling): VirtualScrollResult;
export declare class PerformanceMonitor {
    private metrics;
    private maxSamples;
    constructor(maxSamples?: number);
    startTiming(operation: string): () => void;
    recordMetric(name: string, value: number): void;
    getMetricStats(name: string): {
        count: number;
        average: number;
        min: number;
        max: number;
        p50: number;
        p95: number;
        p99: number;
    } | null;
    getAllMetrics(): Record<string, ReturnType<typeof this.getMetricStats>>;
    clear(): void;
}
export declare const performanceMonitor: PerformanceMonitor;
export declare function getMemoryUsage(): {
    usedJSHeapSize: number;
    totalJSHeapSize: number;
    jsHeapSizeLimit: number;
} | null;
export declare class FrameRateMonitor {
    private frameCount;
    private lastTime;
    private fps;
    private isRunning;
    start(): void;
    stop(): void;
    getFPS(): number;
    private tick;
}
export declare function chunkArray<T>(array: T[], chunkSize: number): T[][];
export declare function processDataAsync<T, R>(data: T[], processor: (item: T, index: number) => R, chunkSize?: number): Promise<R[]>;
export declare class WorkerPool {
    private workerScript;
    private maxWorkers;
    private workers;
    private activeWorkers;
    private queue;
    constructor(workerScript: string, maxWorkers?: number);
    execute<T, R>(data: T): Promise<R>;
    private processQueue;
    private getAvailableWorker;
    private createWorker;
    destroy(): void;
}
export declare function useIntersectionObserver(options?: IntersectionObserverInit): [React.RefCallback<Element>, boolean];
export declare function withPerformanceMonitoring<T extends object>(Component: React.ComponentType<T>, componentName: string): React.ComponentType<T>;
export declare function useBatchedUpdates(): (updateFn: () => void) => void;
export declare class ObjectPool<T> {
    private available;
    private createFn;
    private resetFn?;
    constructor(createFn: () => T, resetFn?: (obj: T) => void, initialSize?: number);
    acquire(): T;
    release(obj: T): void;
    clear(): void;
    size(): {
        available: number;
        total: number;
    };
}
declare const _default: {
    useDebounce: typeof useDebounce;
    useThrottle: typeof useThrottle;
    useVirtualScrolling: typeof useVirtualScrolling;
    useIntersectionObserver: typeof useIntersectionObserver;
    useBatchedUpdates: typeof useBatchedUpdates;
    PerformanceMonitor: typeof PerformanceMonitor;
    FrameRateMonitor: typeof FrameRateMonitor;
    WorkerPool: typeof WorkerPool;
    ObjectPool: typeof ObjectPool;
    performanceMonitor: PerformanceMonitor;
    withPerformanceMonitoring: typeof withPerformanceMonitoring;
    processDataAsync: typeof processDataAsync;
    chunkArray: typeof chunkArray;
    getMemoryUsage: typeof getMemoryUsage;
};
export default _default;
//# sourceMappingURL=performanceUtils.d.ts.map