/**
 * Optimized Cache Manager with improved type safety and performance
 */
import { RedisManager } from "./redis-manager.js";
export interface Memory {
    id: string;
    memory: string;
    metadata?: Record<string, any>;
    created_at: string;
    updated_at?: string;
    user_id: string;
    source?: string;
    relevance_score?: number;
    score_breakdown?: {
        semantic: number;
        keyword: number;
        entity: number;
        relationship: number;
        recency: number;
    };
    matched_entities?: string[];
    matched_relationships?: string[];
}
export interface CacheConfig {
    ttl: {
        l1: number;
        l2: number;
        search: number;
    };
    maxSize: number;
    frequentAccessThreshold: number;
    operationTimeout: number;
}
export interface CacheStats {
    totalMemories: number;
    totalAccess: number;
    hitRate: string;
    memoryUsage: string;
    topAccessed: Array<{
        key: string;
        count: string;
    }>;
}
export declare class CacheKeys {
    static memory: (id: string) => string;
    static access: (id: string) => string;
    static keyword: (word: string) => string;
    static memoryKeywords: (id: string) => string;
    static search: (query: string, limit: number) => string;
    static cacheMetadata: () => string;
}
export declare class CacheManager {
    private redisManager;
    private config;
    private operationQueue;
    constructor(redisManager: RedisManager, config?: Partial<CacheConfig>);
    private withTimeout;
    getCachedMemory(memoryId: string): Promise<Memory | null>;
    private _getCachedMemory;
    setCachedMemory(memoryId: string, data: Memory, ttl?: number): Promise<void>;
    private _setCachedMemory;
    private trackAccessAtomic;
    private getAccessCount;
    getCacheStats(): Promise<CacheStats>;
    private _getCacheStats;
    private scanCount;
    private indexMemoryForSearchAsync;
    private extractKeywords;
    deleteCachedMemory(memoryId: string): Promise<void>;
    private _deleteCachedMemory;
    private determineTTL;
    batchGet(memoryIds: string[]): Promise<(Memory | null)[]>;
    batchSet(memories: Memory[], ttl?: number): Promise<void>;
    getCachedSearch(query: string, limit: number): Promise<Memory[] | null>;
    getCachedSearchResults(query: string, limit: number): Promise<Memory[] | null>;
    setCachedSearch(query: string, limit: number, results: Memory[]): Promise<void>;
    cacheSearchResults(query: string, limit: number, results: Memory[]): Promise<void>;
    searchFromCache(pattern: string, limit: number): Promise<Memory[]>;
    invalidateSearchCache(): Promise<void>;
    optimizeCache(memories: Memory[], maxMemories: number, forceRefresh: boolean): Promise<{
        cached: number;
        duration: string;
    }>;
}
//# sourceMappingURL=cache-manager-optimized.d.ts.map