/**
 * Módulo extremadamente modular para manejo de caché
 * Mantiene último valor válido y recuperación cuando no hay valor disponible
 */
export interface CacheEntry<T> {
    value: T;
    timestamp: Date;
    source: string;
    isValid: boolean;
    expiresAt?: Date;
}
export interface CacheConfig {
    defaultTtl?: number;
    maxEntries?: number;
    enablePersistence?: boolean;
}
export interface CacheStats {
    totalEntries: number;
    validEntries: number;
    expiredEntries: number;
    lastUpdate: Date | null;
    hitRate: number;
    missRate: number;
}
export declare enum CacheEventType {
    SET = "SET",
    GET = "GET",
    HIT = "HIT",
    MISS = "MISS",
    EXPIRE = "EXPIRE",
    CLEAR = "CLEAR"
}
export interface CacheEvent {
    type: CacheEventType;
    key: string;
    timestamp: Date;
    metadata?: any;
}
/**
 * Clase para validar entradas de caché
 */
export declare class CacheValidator {
    /**
     * Valida si un valor es válido para el caché
     */
    static isValidValue<T>(value: T): boolean;
    /**
     * Valida si una entrada de caché no ha expirado
     */
    static isNotExpired<T>(entry: CacheEntry<T>): boolean;
    /**
     * Valida si una entrada de caché es utilizable
     */
    static isUsableEntry<T>(entry: CacheEntry<T>): boolean;
}
/**
 * Clase para métricas y estadísticas de caché
 */
export declare class CacheMetrics {
    private hits;
    private misses;
    private events;
    private maxEvents;
    /**
     * Registra un hit en el caché
     */
    recordHit(key: string): void;
    /**
     * Registra un miss en el caché
     */
    recordMiss(key: string): void;
    /**
     * Registra un evento en el caché
     */
    recordEvent(event: CacheEvent): void;
    /**
     * Obtiene estadísticas del caché
     */
    getStats(): {
        hitRate: number;
        missRate: number;
        totalRequests: number;
    };
    /**
     * Obtiene eventos recientes
     */
    getRecentEvents(limit?: number): CacheEvent[];
    /**
     * Reinicia las métricas
     */
    reset(): void;
}
/**
 * Clase principal para manejo de caché en memoria
 */
export declare class InMemoryCache<T> {
    private cache;
    private config;
    private metrics;
    constructor(config?: CacheConfig);
    /**
     * Almacena un valor en el caché
     */
    set(key: string, value: T, source?: string, ttl?: number): boolean;
    /**
     * Obtiene un valor del caché
     */
    get(key: string): T | null;
    /**
     * Obtiene la entrada completa del caché
     */
    getEntry(key: string): CacheEntry<T> | null;
    /**
     * Verifica si existe una clave en el caché
     */
    has(key: string): boolean;
    /**
     * Elimina una entrada del caché
     */
    delete(key: string): boolean;
    /**
     * Limpia todas las entradas del caché
     */
    clear(): void;
    /**
     * Limpia entradas expiradas
     */
    cleanExpiredEntries(): number;
    /**
     * Obtiene la clave más antigua
     */
    private getOldestKey;
    /**
     * Obtiene estadísticas del caché
     */
    getStats(): CacheStats;
    /**
     * Obtiene todas las claves del caché
     */
    getKeys(): string[];
    /**
     * Obtiene el tamaño del caché
     */
    size(): number;
}
/**
 * Clase especializada para caché de tasas de cambio con rotación inteligente
 */
export declare class ExchangeRateCache {
    private cache;
    private fallbackCache;
    private updateCounters;
    constructor(config?: CacheConfig);
    /**
     * Almacena una tasa exitosa con lógica de rotación inteligente
     * 1ra consulta: Cache Principal + Fallback
     * 2da consulta: Solo Cache Principal
     * 3ra+ consulta: Principal -> Fallback, nuevo valor -> Principal
     */
    setSuccessfulRate(key: string, rate: string, source: string): boolean;
    /**
     * Obtiene una tasa del caché
     */
    getRate(key: string): string | null;
    /**
     * Obtiene una tasa de fallback cuando la principal no está disponible
     */
    getFallbackRate(key: string): string | null;
    /**
     * Obtiene una tasa con fallback automático
     */
    getRateWithFallback(key: string): {
        rate: string | null;
        source: 'cache' | 'fallback' | null;
    };
    /**
     * Limpia caché expirado
     */
    cleanup(): {
        main: number;
        fallback: number;
    };
    /**
     * Obtiene estadísticas completas
     */
    getCompleteStats(): {
        main: CacheStats;
        fallback: CacheStats;
    };
    /**
     * Limpia todos los cachés y contadores
     */
    clearAll(): void;
    /**
     * Obtiene el contador de actualizaciones para una clave
     */
    getUpdateCount(key: string): number;
    /**
     * Obtiene estadísticas de contadores de actualización
     */
    getUpdateCountersStats(): {
        totalKeys: number;
        counters: Record<string, number>;
    };
}
/**
 * Instancia global del caché de tasas de cambio
 */
export declare const globalExchangeRateCache: ExchangeRateCache;
/**
 * Funciones de conveniencia para el caché global
 */
export declare const setSuccessfulRate: (key: string, rate: string, source: string) => boolean;
export declare const getRate: (key: string) => string | null;
export declare const getRateWithFallback: (key: string) => {
    rate: string | null;
    source: "cache" | "fallback" | null;
};
export declare const cleanupCache: () => {
    main: number;
    fallback: number;
};
//# sourceMappingURL=cache-manager.d.ts.map