import { ICache, CacheStats, CacheOptions } from './cache';
import { ExpertType, ExpertOutput } from '../types/workflow';
/**
 * Advanced caching interfaces
 */
export interface CacheWarmupConfig {
    enabled: boolean;
    patterns: string[];
    batchSize: number;
    intervalMs: number;
    priority: CachePriority;
}
export interface CacheInvalidationRule {
    pattern: string | RegExp;
    strategy: 'immediate' | 'lazy' | 'ttl-based';
    dependencies?: string[];
}
export interface SmartCacheEntry<T> {
    value: T;
    metadata: CacheEntryMetadata;
    tags: Set<string>;
    dependencies: Set<string>;
    priority: CachePriority;
}
export interface CacheEntryMetadata {
    createdAt: number;
    lastAccessed: number;
    accessCount: number;
    accessPattern: AccessPattern;
    size: number;
    hitScore: number;
    warmupSource?: boolean;
}
export interface AccessPattern {
    frequency: number;
    recency: number;
    seasonality?: number;
    predictedNextAccess?: number;
}
export declare enum CachePriority {
    LOW = 1,
    NORMAL = 2,
    HIGH = 3,
    CRITICAL = 4
}
/**
 * Intelligent cache with context awareness and predictive warming
 */
export declare class SmartCache<T> implements ICache<T> {
    private options;
    private cache;
    private tagIndex;
    private dependencyGraph;
    private invalidationRules;
    private warmupConfig?;
    private warmupInterval?;
    private logger;
    private stats;
    constructor(options: CacheOptions & {
        warmupConfig?: CacheWarmupConfig;
        invalidationRules?: CacheInvalidationRule[];
    });
    /**
     * Enhanced get with prediction and pattern learning
     */
    get(key: string): T | undefined;
    /**
     * Compatible with ICache interface
     */
    set(key: string, value: T, ttlMs?: number): void;
    /**
     * Enhanced set with tagging and dependency tracking
     */
    setAdvanced(key: string, value: T, options?: {
        ttlMs?: number;
        tags?: string[];
        dependencies?: string[];
        priority?: CachePriority;
        metadata?: Partial<CacheEntryMetadata>;
    }): void;
    /**
     * Invalidate by tag with dependency cascade
     */
    invalidateByTag(tag: string): number;
    /**
     * Invalidate by pattern with rule-based strategy
     */
    invalidateByPattern(pattern: string | RegExp): number;
    /**
     * Warm cache with intelligent prefetching
     */
    warmCache(warmupFunction: (key: string) => Promise<T | null>): Promise<number>;
    has(key: string): boolean;
    delete(key: string): boolean;
    clear(): void;
    size(): number;
    keys(): string[];
    getStats(): CacheStats & SmartCacheStats;
    /**
     * Get advanced analytics
     */
    getAdvancedStats(): CacheAnalytics;
    destroy(): void;
    private isExpired;
    private updateAccessPattern;
    private predictAndWarm;
    private evictIfNecessary;
    private selectEvictionVictim;
    private calculateEvictionScore;
    private invalidateWithCascade;
    private invalidateEntry;
    private addToIndices;
    private removeFromIndices;
    private initializeBasicStats;
    private initializeAccessPattern;
    private estimateSize;
    private calculateFrequency;
    private calculateRecency;
    private calculateHitScore;
    private updateStats;
    private calculateTotalMemoryUsage;
    private calculateAverageHitScore;
    private analyzeAccessPatterns;
    private analyzePriorityDistribution;
    private analyzeTagUtilization;
    private analyzeDependencyGraph;
    private calculateMemoryEfficiency;
    private calculatePredictionMetrics;
    private generateWarmupKeys;
    private findRelatedKeys;
    private shouldWarmKey;
    private scheduleKeyWarming;
    private calculateWarmupImpact;
    private startCacheWarming;
    private startPredictiveAnalysis;
    private analyzePredictivePatterns;
}
interface SmartCacheStats extends CacheStats {
    warmupHits: number;
    predictionAccuracy: number;
    taggedEntries: number;
    dependentInvalidations: number;
    priorityEvictions: number;
}
interface CacheAnalytics {
    totalEntries: number;
    averageHitScore: number;
    accessPatterns: AccessPatternAnalysis;
    priorityDistribution: Record<string, number>;
    tagUtilization: TagUtilizationAnalysis;
    dependencyGraph: DependencyAnalysis;
    memoryEfficiency: MemoryEfficiency;
    predictionMetrics: PredictionMetrics;
}
interface AccessPatternAnalysis {
    averageFrequency: number;
    averageRecency: number;
    highFrequencyEntries: number;
    staleFriction: number;
}
interface TagUtilizationAnalysis {
    totalTags: number;
    averageKeysPerTag: number;
    maxKeysPerTag: number;
    underutilizedTags: number;
}
interface DependencyAnalysis {
    totalDependencies: number;
    averageDependentsPerKey: number;
    maxDependentsPerKey: number;
    cascadeRisk: number;
}
interface MemoryEfficiency {
    utilization: number;
    wastePercentage: number;
    averageEntrySize: number;
}
interface PredictionMetrics {
    accuracy: number;
    totalPredictions: number;
    correctPredictions: number;
    falsePositives: number;
}
/**
 * Expert-specific smart cache for intelligent workflow caching
 */
export declare class ExpertResponseCache extends SmartCache<ExpertOutput> {
    constructor();
    /**
     * Get expert response with context-aware caching
     */
    getExpertResponse(expertType: ExpertType, projectHash: string, contextHash?: string): ExpertOutput | undefined;
    /**
     * Cache expert response with intelligent tagging
     */
    cacheExpertResponse(expertType: ExpertType, projectHash: string, output: ExpertOutput, contextHash?: string, workflowId?: string): void;
    private generateExpertKey;
}
export declare const expertResponseCache: ExpertResponseCache;
export {};
//# sourceMappingURL=advancedCache.d.ts.map