/**
 * @file useMemoryPressure Hook
 * @description React hook for monitoring JavaScript heap memory usage and pressure.
 *
 * Provides components with awareness of memory conditions, enabling
 * adaptive behavior to prevent memory-related performance degradation.
 *
 * Note: The Memory API (performance.memory) is only available in Chrome/Chromium browsers.
 * This hook gracefully degrades on unsupported browsers.
 *
 * @example
 * ```tsx
 * function MyComponent() {
 *   const {
 *     pressure,
 *     usagePercent,
 *     isUnderPressure,
 *     shouldReduceMemory
 *   } = useMemoryPressure({
 *     onPressureChange: (pressure) => {
 *       if (pressure === 'critical') {
 *         clearCaches();
 *       }
 *     }
 *   });
 *
 *   // Reduce memory usage when under pressure
 *   if (shouldReduceMemory) {
 *     return <LiteVersion />;
 *   }
 *
 *   return <FullVersion />;
 * }
 * ```
 */
/**
 * Memory pressure level
 */
export type MemoryPressureLevel = 'normal' | 'warning' | 'critical';
/**
 * Memory snapshot
 */
export interface MemorySnapshot {
    /** Used JS heap size in bytes */
    readonly usedJSHeapSize: number;
    /** Total JS heap size in bytes */
    readonly totalJSHeapSize: number;
    /** JS heap size limit in bytes */
    readonly jsHeapSizeLimit: number;
    /** Usage as percentage (0-100) */
    readonly usagePercent: number;
    /** Current pressure level */
    readonly pressure: MemoryPressureLevel;
    /** Timestamp of snapshot */
    readonly timestamp: number;
}
/**
 * Memory trend data
 */
export interface MemoryTrend {
    /** Direction of memory usage */
    readonly direction: 'increasing' | 'stable' | 'decreasing';
    /** Rate of change (bytes per second) */
    readonly rateOfChange: number;
    /** Estimated time until critical (ms) or null if not increasing */
    readonly timeUntilCritical: number | null;
}
/**
 * Hook options
 */
export interface UseMemoryPressureOptions {
    /** Warning threshold (0-1) */
    readonly warningThreshold?: number;
    /** Critical threshold (0-1) */
    readonly criticalThreshold?: number;
    /** Polling interval (ms) */
    readonly pollingInterval?: number;
    /** Callback on pressure change */
    readonly onPressureChange?: (pressure: MemoryPressureLevel, snapshot: MemorySnapshot) => void;
    /** Callback on critical pressure */
    readonly onCritical?: (snapshot: MemorySnapshot) => void;
    /** Enable automatic cleanup on critical */
    readonly autoCleanup?: boolean;
    /** Custom cleanup function */
    readonly cleanupFn?: () => void;
    /** Enable debug logging */
    readonly debug?: boolean;
}
/**
 * Hook return value
 */
export interface UseMemoryPressureReturn {
    /** Current memory snapshot */
    readonly snapshot: MemorySnapshot | null;
    /** Current pressure level */
    readonly pressure: MemoryPressureLevel;
    /** Usage percentage (0-100) */
    readonly usagePercent: number;
    /** Whether under any pressure (warning or critical) */
    readonly isUnderPressure: boolean;
    /** Whether should reduce memory usage */
    readonly shouldReduceMemory: boolean;
    /** Memory trend */
    readonly trend: MemoryTrend | null;
    /** Whether Memory API is supported */
    readonly isSupported: boolean;
    /** Force a memory snapshot */
    readonly refresh: () => void;
    /** Request garbage collection (if available) */
    readonly requestGC: () => void;
    /** Get memory history */
    readonly getHistory: () => MemorySnapshot[];
    /** Format bytes for display */
    readonly formatBytes: (bytes: number) => string;
}
/**
 * Hook for memory pressure monitoring
 */
export declare function useMemoryPressure(options?: UseMemoryPressureOptions): UseMemoryPressureReturn;
/**
 * Hook that triggers cleanup when memory pressure is detected
 */
export declare function useMemoryCleanup(cleanupFn: () => void, options?: {
    threshold?: MemoryPressureLevel;
}): void;
/**
 * Hook that provides memory-aware caching
 */
export declare function useMemoryAwareCache<T>(maxSize?: number): {
    get: (key: string) => T | undefined;
    set: (key: string, value: T) => void;
    clear: () => void;
    size: number;
};
/**
 * Hook that monitors component memory impact
 */
export declare function useComponentMemoryImpact(): {
    mountSize: number | null;
    currentSize: number | null;
    impact: number | null;
};