/**
 * @file Memory Manager
 * @description Enterprise-grade memory management utilities with resource pooling,
 * WeakMap caching, garbage collection hints, and automatic cleanup
 */
/**
 * Resource pool configuration
 */
export interface ResourcePoolConfig<T> {
    /** Factory function to create new resources */
    factory: () => T;
    /** Maximum pool size */
    maxSize?: number;
    /** Minimum pool size (pre-allocated) */
    minSize?: number;
    /** Time-to-live for idle resources (ms) */
    idleTTL?: number;
    /** Validation function before reuse */
    validate?: (resource: T) => boolean;
    /** Cleanup function when resource is disposed */
    dispose?: (resource: T) => void;
    /** Reset function before reuse */
    reset?: (resource: T) => void;
}
/**
 * Generic resource pool for expensive objects
 * Implements object pooling pattern to reduce GC pressure
 */
export declare class ResourcePool<T> {
    private pool;
    private config;
    private cleanupInterval;
    constructor(config: ResourcePoolConfig<T>);
    /**
     * Acquire a resource from the pool
     */
    acquire(): {
        resource: T;
        release: () => void;
    };
    /**
     * Cleanup idle resources beyond minimum
     */
    cleanup(): void;
    /**
     * Get pool statistics
     */
    getStats(): {
        total: number;
        acquired: number;
        available: number;
        maxSize: number;
    };
    /**
     * Dispose all resources and stop cleanup
     */
    dispose(): void;
    /**
     * Pre-allocate minimum pool resources
     */
    private preallocate;
    /**
     * Create a new pool entry
     */
    private createEntry;
    /**
     * Release a resource back to the pool
     */
    private release;
    /**
     * Start periodic cleanup of idle resources
     */
    private startCleanup;
}
/**
 * WeakMap-based cache with TTL support
 * Uses WeakRef for automatic garbage collection
 */
export declare class WeakCache<K extends object, V> {
    private cache;
    private registry;
    private readonly defaultTTL;
    constructor(options?: {
        defaultTTL?: number;
    });
    /**
     * Get cached value
     */
    get(key: K): V | undefined;
    /**
     * Set cached value
     */
    set(key: K, value: V, ttl?: number): void;
    /**
     * Check if key exists
     */
    has(key: K): boolean;
    /**
     * Delete cached value
     */
    delete(key: K): boolean;
    /**
     * Clear all cached values
     */
    clear(): void;
}
/**
 * Memory pressure levels
 */
export type MemoryPressure = 'none' | 'moderate' | 'critical';
/**
 * Memory pressure callback
 */
export type MemoryPressureCallback = (pressure: MemoryPressure) => void;
/**
 * Memory monitor configuration
 */
export interface MemoryMonitorConfig {
    /** Moderate pressure threshold (0-1) */
    moderateThreshold?: number;
    /** Critical pressure threshold (0-1) */
    criticalThreshold?: number;
    /** Check interval (ms) */
    checkInterval?: number;
}
/**
 * Memory monitor for tracking heap usage and pressure
 */
export declare class MemoryMonitor {
    private callbacks;
    private config;
    private interval;
    private currentPressure;
    constructor(config?: MemoryMonitorConfig);
    /**
     * Start monitoring memory pressure
     */
    start(): void;
    /**
     * Stop monitoring
     */
    stop(): void;
    /**
     * Check current memory pressure
     */
    check(): MemoryPressure;
    /**
     * Get detailed memory info
     */
    getMemoryInfo(): {
        usedHeap: number;
        totalHeap: number;
        heapLimit: number;
        usageRatio: number;
        pressure: MemoryPressure;
    } | null;
    /**
     * Subscribe to pressure changes
     */
    onPressureChange(callback: MemoryPressureCallback): () => void;
    /**
     * Suggest garbage collection (hint only)
     */
    suggestGC(): void;
    /**
     * Get memory usage ratio (0-1)
     */
    private getUsageRatio;
    /**
     * Notify callbacks of pressure change
     */
    private notifyCallbacks;
}
/**
 * Disposable interface for cleanup
 */
export interface Disposable {
    dispose(): void;
}
/**
 * Disposable registry for tracking resources
 */
export declare class DisposableRegistry {
    private disposables;
    private isDisposed;
    /**
     * Get registration count
     */
    get count(): number;
    /**
     * Register a disposable resource
     */
    register<T extends Disposable>(disposable: T): T;
    /**
     * Unregister a disposable
     */
    unregister(disposable: Disposable): boolean;
    /**
     * Dispose all registered resources
     */
    dispose(): void;
}
/**
 * Create a disposable from a cleanup function
 */
export declare function createDisposable(cleanup: () => void): Disposable;
/**
 * LRU (Least Recently Used) Cache with size limits
 */
export declare class LRUCache<K, V> {
    private cache;
    private readonly maxSize;
    constructor(maxSize: number);
    /**
     * Get cache size
     */
    get size(): number;
    /**
     * Get value and mark as recently used
     */
    get(key: K): V | undefined;
    /**
     * Set value
     */
    set(key: K, value: V): void;
    /**
     * Check if key exists
     */
    has(key: K): boolean;
    /**
     * Delete key
     */
    delete(key: K): boolean;
    /**
     * Clear cache
     */
    clear(): void;
    /**
     * Get all entries
     */
    entries(): IterableIterator<[K, V]>;
}
/**
 * Global memory manager singleton
 */
export declare const memoryManager: {
    monitor: MemoryMonitor;
    registry: DisposableRegistry;
    /**
     * Create a resource pool
     */
    createPool<T>(config: ResourcePoolConfig<T>): ResourcePool<T>;
    /**
     * Create an LRU cache
     */
    createLRUCache<K, V>(maxSize: number): LRUCache<K, V>;
    /**
     * Start memory monitoring
     */
    startMonitoring(): void;
    /**
     * Stop memory monitoring
     */
    stopMonitoring(): void;
    /**
     * Dispose all managed resources
     */
    dispose(): void;
};