import { SupportedLanguage, TranslationResult } from './types';
/**
 * 高级缓存策略类型
 */
export declare enum CacheStrategy {
    LRU = "lru",// 最近最少使用
    LFU = "lfu",// 最少使用频次
    ADAPTIVE = "adaptive",// 自适应策略
    PREDICTIVE = "predictive",// 预测性缓存
    HIERARCHICAL = "hierarchical",// 分层缓存
    DISTRIBUTED = "distributed",// 分布式缓存
    INTELLIGENT = "intelligent"
}
/**
 * 缓存层级定义
 */
export declare enum CacheLayer {
    L1_MEMORY = "l1_memory",// L1: 内存缓存 (最快)
    L2_STORAGE = "l2_storage",// L2: 本地存储缓存
    L3_DISK = "l3_disk",// L3: 磁盘缓存
    L4_NETWORK = "l4_network",// L4: 网络缓存
    L5_CLOUD = "l5_cloud"
}
/**
 * 缓存性能指标
 */
export interface CachePerformanceMetrics {
    hitRate: number;
    missRate: number;
    averageLatency: number;
    throughput: number;
    memoryEfficiency: number;
    compressionRatio: number;
    evictionRate: number;
    fragmentation: number;
}
/**
 * 智能缓存决策参数
 */
export interface CacheDecisionFactors {
    accessFrequency: number;
    recency: number;
    textLength: number;
    complexity: number;
    translationCost: number;
    memoryFootprint: number;
    networkLatency: number;
    popularityScore: number;
}
/**
 * 缓存预测模型
 */
export interface CachePredictionModel {
    modelType: 'linear' | 'neural' | 'ensemble';
    features: string[];
    weights: number[];
    accuracy: number;
    lastTrained: Date;
}
/**
 * 缓存预加载配置
 */
export interface CachePreloadConfig {
    enabled: boolean;
    triggers: Array<'time' | 'usage' | 'pattern' | 'prediction'>;
    timeBasedPreload: {
        schedule: string;
        languages: SupportedLanguage[];
        contentTypes: string[];
    };
    usageBasedPreload: {
        threshold: number;
        lookAheadWindow: number;
        maxPreloadSize: number;
    };
    patternBasedPreload: {
        detectPatterns: boolean;
        patternTypes: string[];
        confidenceThreshold: number;
    };
}
/**
 * 超级缓存管理器 - 多层级智能缓存系统
 */
export declare class SuperCacheManager {
    private layers;
    private strategy;
    private profiler;
    private metrics;
    private predictionModel;
    private preloadConfig;
    private decisionEngine;
    private preloadEngine;
    private compressionEngine;
    private performanceMonitor;
    private adaptiveOptimizer;
    private accessPatterns;
    private hotKeys;
    private coldKeys;
    constructor(config?: {
        strategy?: CacheStrategy;
        layers?: CacheLayer[];
        preloadConfig?: Partial<CachePreloadConfig>;
        enablePrediction?: boolean;
        enableCompression?: boolean;
    });
    /**
     * 智能缓存获取 - 主入口方法
     */
    get(key: string, options?: {
        strategy?: CacheStrategy;
        allowStale?: boolean;
        updateTTL?: boolean;
        preloadRelated?: boolean;
    }): Promise<TranslationResult | null>;
    /**
     * 智能缓存设置
     */
    set(key: string, value: TranslationResult, options?: {
        ttl?: number;
        priority?: number;
        layers?: CacheLayer[];
        compress?: boolean;
        replicate?: boolean;
    }): Promise<boolean>;
    /**
     * 批量智能缓存操作
     */
    multiGet(keys: string[], options?: {
        strategy?: CacheStrategy;
        parallel?: boolean;
        maxConcurrency?: number;
    }): Promise<Map<string, TranslationResult | null>>;
    /**
     * 智能预加载
     */
    intelligentPreload(context?: {
        userId?: string;
        sessionId?: string;
        currentLanguage?: SupportedLanguage;
        targetLanguages?: SupportedLanguage[];
        contentType?: string;
        timeWindow?: number;
    }): Promise<{
        preloadedCount: number;
        estimatedHitRate: number;
        memoryUsed: number;
        timeSpent: number;
    }>;
    /**
     * 多层级获取实现
     */
    private multilayerGet;
    /**
     * 选择最优缓存策略
     */
    private selectOptimalStrategy;
    /**
     * 初始化缓存层级
     */
    private initializeLayers;
    /**
     * 获取层级配置
     */
    private getLayerConfig;
    /**
     * 获取层级搜索顺序
     */
    private getLayerSearchOrder;
    /**
     * 记录访问模式
     */
    private recordAccess;
    /**
     * 启动性能监控
     */
    private startPerformanceMonitoring;
    /**
     * 启动自适应优化
     */
    private startAdaptiveOptimization;
    /**
     * 创建性能指标空对象
     */
    private createEmptyMetrics;
    /**
     * 获取当前性能统计
     */
    getPerformanceMetrics(): CachePerformanceMetrics;
    /**
     * 获取缓存统计信息
     */
    getCacheStats(): {
        layers: Map<CacheLayer, any>;
        totalSize: number;
        totalItems: number;
        hitRate: number;
        memoryUsage: number;
    };
    /**
     * 清理过期数据
     */
    private initializePredictionModel;
    private preloadRelatedContent;
    private updateMetrics;
    private writeToLayer;
    private updateHotspotTracking;
    private shouldPreload;
    private preloadContent;
    private calculatePreloadEfficiency;
    private promoteToFasterLayers;
    private getLayerSpeed;
    private getLayerEfficiency;
    private calculateAccessVolatility;
    private updateHotColdTracking;
    cleanup(): Promise<void>;
    /**
     * 导出性能报告
     */
    generatePerformanceReport(): string;
    private createChunks;
    private getCurrentMemoryUsage;
}
/**
 * 访问模式接口
 */
export interface AccessPattern {
    key: string;
    frequency: number;
    lastAccessed: number;
    firstAccessed: number;
    accessTimes: number[];
    averageSize: number;
    volatility: number;
}
/**
 * 缓存决策引擎
 */
export declare class CacheDecisionEngine {
    selectOptimalLayers(key: string, value: TranslationResult, options?: any): Promise<CacheLayer[]>;
}
/**
 * 缓存预加载引擎
 */
export declare class CachePreloadEngine {
    predictByUsage(context: any, accessPatterns: Map<string, AccessPattern>, config: any): Promise<PreloadPrediction[]>;
    predictByPattern(accessPatterns: Map<string, AccessPattern>, config: any): Promise<PreloadPrediction[]>;
    predictByML(model: CachePredictionModel, context: any, accessPatterns: Map<string, AccessPattern>): Promise<PreloadPrediction[]>;
}
/**
 * 缓存压缩引擎
 */
export declare class CacheCompressionEngine {
    compress(value: TranslationResult): Promise<TranslationResult>;
    decompress(value: TranslationResult): Promise<TranslationResult>;
}
/**
 * 预加载预测结果
 */
export interface PreloadPrediction {
    key: string;
    confidence: number;
    estimatedSize: number;
    priority: number;
    metadata?: any;
}
//# sourceMappingURL=super-cache-manager.d.ts.map