/**
 * Advanced Cache Manager
 * Implements intelligent caching with semantic similarity, warming, and distributed support
 */
import { EventEmitter } from 'events';
import { CacheStats, AdvancedCacheConfig, MultiTierCacheConfig } from './types';
export declare class AdvancedCache<T = unknown> extends EventEmitter {
    private config;
    private cache;
    private accessLog;
    private stats;
    private warmupSchedule?;
    private persistenceInterval?;
    constructor(config: AdvancedCacheConfig);
    /**
     * Get value from cache
     */
    get(key: string): Promise<T | null>;
    /**
     * Set value in cache
     */
    set(key: string, value: T, options?: {
        ttl?: number;
        priority?: number;
        tags?: string[];
        dependencies?: string[];
    }): Promise<void>;
    /**
     * Delete from cache
     */
    delete(key: string): Promise<boolean>;
    /**
     * Clear entire cache
     */
    clear(): void;
    /**
     * Evict entries based on strategy
     */
    private evict;
    /**
     * Find LRU (Least Recently Used) key
     */
    private findLRUKey;
    /**
     * Find LFU (Least Frequently Used) key
     */
    private findLFUKey;
    /**
     * Find FIFO (First In First Out) key
     */
    private findFIFOKey;
    /**
     * Find key using adaptive strategy
     */
    private findAdaptiveKey;
    /**
     * Evict by memory constraint
     */
    private evictByMemory;
    /**
     * Get semantic match
     */
    private getSemanticMatch;
    /**
     * Calculate similarity (simple implementation)
     */
    private calculateSimilarity;
    /**
     * Invalidate dependent entries
     */
    private invalidateDependents;
    /**
     * Invalidate by pattern
     */
    invalidateByPattern(pattern: string): Promise<number>;
    /**
     * Invalidate by tags
     */
    invalidateByTags(tags: string[]): Promise<number>;
    /**
     * Warm up cache
     */
    warmup(keys: string[], loader: (key: string) => Promise<T>): Promise<void>;
    /**
     * Initialize warmup schedule
     */
    private initializeWarmup;
    /**
     * Initialize persistence
     */
    private initializePersistence;
    /**
     * Persist cache to storage
     */
    private persist;
    /**
     * Estimate size of value
     */
    private estimateSize;
    /**
     * Record operation
     */
    private recordOperation;
    /**
     * Update hit rate
     */
    private updateHitRate;
    /**
     * Get statistics
     */
    getStats(): CacheStats;
    /**
     * Get all keys
     */
    keys(): string[];
    /**
     * Get entries by tag
     */
    getByTag(tag: string): Array<{
        key: string;
        value: T;
    }>;
    /**
     * Cleanup and shutdown
     */
    shutdown(): Promise<void>;
    /**
     * Get health status
     */
    getHealth(): {
        healthy: boolean;
        stats: CacheStats;
        memoryUtilization: number;
        sizeUtilization: number;
    };
}
/**
 * Multi-tier cache with promotion/demotion
 */
export declare class MultiTierCache<T = unknown> extends EventEmitter {
    private layers;
    private config;
    constructor(config: MultiTierCacheConfig);
    /**
     * Get from multi-tier cache
     */
    get(key: string): Promise<T | null>;
    /**
     * Set in multi-tier cache
     */
    set(key: string, value: T): Promise<void>;
    /**
     * Promote entry to higher tiers
     */
    private promote;
    /**
     * Clear all tiers
     */
    clear(): Promise<void>;
    /**
     * Get aggregated statistics
     */
    getStats(): Record<string, CacheStats>;
}
//# sourceMappingURL=manager.d.ts.map