import { MemoryProfile, OptimizationConfig } from './types.js';
export declare class MemoryManager {
    private static instance;
    private config;
    private memoryProfiles;
    private caches;
    private monitoringInterval?;
    private gcThreshold;
    private lastGC;
    constructor(config: OptimizationConfig['memory']);
    static getInstance(config?: OptimizationConfig['memory']): MemoryManager;
    private startMonitoring;
    private recordMemoryUsage;
    private checkMemoryThresholds;
    private cleanupCaches;
    private evictLeastRecentlyUsedCaches;
    private emergencyCleanup;
    private triggerGarbageCollection;
    registerCache(name: string, cache: any): void;
    unregisterCache(name: string): void;
    getTotalCacheSize(): number;
    getMemoryStats(): {
        current: MemoryProfile;
        history: MemoryProfile[];
        cacheSize: number;
        cacheCount: number;
        thresholds: {
            maxHeap: number;
            gcThreshold: number;
            cacheEvictionThreshold: number;
        };
    };
    optimizeMemoryUsage(): Promise<void>;
    createMemoryEfficientArray<T>(initialCapacity?: number): MemoryEfficientArray<T>;
    createMemoryEfficientMap<K, V>(maxSize?: number): MemoryEfficientMap<K, V>;
    setMemoryThresholds(config: Partial<OptimizationConfig['memory']>): void;
    private getGCCount;
    destroy(): void;
}
export declare class MemoryEfficientArray<T> {
    private chunks;
    private chunkSize;
    private _length;
    constructor(chunkSize?: number);
    push(item: T): void;
    get(index: number): T | undefined;
    get length(): number;
    [Symbol.iterator](): Iterator<T>;
    clear(): void;
}
export declare class MemoryEfficientMap<K, V> {
    private map;
    private maxSize;
    constructor(maxSize: number);
    set(key: K, value: V): void;
    get(key: K): V | undefined;
    has(key: K): boolean;
    delete(key: K): boolean;
    clear(): void;
    get size(): number;
    private evictOldest;
}
//# sourceMappingURL=MemoryManager.d.ts.map