export interface CacheEntry<T = unknown> {
    key: string;
    value: T;
    tier: 'hot' | 'warm' | 'cold';
    createdAt: number;
    lastAccess: number;
    accessCount: number;
    ttl: number;
    size: number;
    compressed: boolean;
    tags: string[];
}
export interface CacheConfig {
    maxHotEntries: number;
    maxWarmEntries: number;
    maxColdEntries: number;
    defaultTTL: number;
    hotPromotionThreshold: number;
    coldDemotionThreshold: number;
    compressionThreshold: number;
    enablePrefetch: boolean;
    maxMemoryMB: number;
}
export interface CacheStats {
    hotEntries: number;
    warmEntries: number;
    coldEntries: number;
    totalEntries: number;
    hits: number;
    misses: number;
    hitRate: number;
    evictions: number;
    promotions: number;
    demotions: number;
    memoryUsageMB: number;
    prefetchHits: number;
    avgAccessTime: number;
}
export interface PrefetchHint {
    key: string;
    probability: number;
    basedOn: string[];
}
export declare class SmartCache {
    private hot;
    private warm;
    private cold;
    private config;
    private accessLog;
    private prefetchGraph;
    private hits;
    private misses;
    private evictions;
    private promotions;
    private demotions;
    private prefetchHits;
    private totalAccessTime;
    private accessTimeCount;
    constructor(config?: Partial<CacheConfig>);
    get<T = unknown>(key: string): T | undefined;
    set<T = unknown>(key: string, value: T, options?: {
        ttl?: number;
        tags?: string[];
        tier?: 'hot' | 'warm';
    }): void;
    delete(key: string): boolean;
    has(key: string): boolean;
    clear(): void;
    getMany<T = unknown>(keys: string[]): Map<string, T>;
    setMany<T = unknown>(entries: Array<{
        key: string;
        value: T;
        ttl?: number;
    }>): void;
    getByTag<T = unknown>(tag: string): Map<string, T>;
    invalidateByTag(tag: string): number;
    getOrCompute<T>(key: string, compute: () => T | Promise<T>, options?: {
        ttl?: number;
        tags?: string[];
    }): Promise<T>;
    private promote;
    private enforceHotLimit;
    private enforceWarmLimit;
    private enforceColdLimit;
    private findLeastRecentlyUsed;
    private isExpired;
    private trackAccess;
    private triggerPrefetch;
    getPrefetchHints(key: string, limit?: number): PrefetchHint[];
    cleanup(): number;
    demoteStale(): number;
    private recordAccessTime;
    stats(): CacheStats;
    private estimateMemory;
    keys(): string[];
    size(): number;
    getConfig(): CacheConfig;
    updateConfig(updates: Partial<CacheConfig>): void;
}
//# sourceMappingURL=smart-cache.d.ts.map