import { Model } from "sequelize";
export interface RedisOptions {
    url?: string;
    host?: string;
    port?: number;
    password?: string;
    db?: number;
    keyPrefix?: string;
    client?: any;
    enableClusterSync?: boolean;
    reconnectStrategy?: {
        retries?: number;
        factor?: number;
        minTimeout?: number;
        maxTimeout?: number;
    };
}
export interface CacheManagerOptions<T extends Model> {
    keyFields?: string | string[];
    refreshIntervalMs?: number;
    minAutoSyncInterval?: number;
    ttlMs?: number | null;
    cleanupIntervalMs?: number;
    lazyReload?: boolean;
    staleWhileRevalidate?: boolean;
    maxSize?: number;
    redis?: RedisOptions;
    logger?: CacheLogger;
}
export type PlainRecord = Record<string, any>;
export interface CacheLogger {
    info?(...args: any[]): void;
    warn?(...args: any[]): void;
    error?(...args: any[]): void;
    debug?(...args: any[]): void;
}
export interface CacheStats {
    total: number;
    maxSize: number | null;
    byKey: Record<string, number>;
    metrics: {
        hits: number;
        misses: number;
        evictions: number;
        totalRequests: number;
        hitRate: number;
    };
    lastSyncAt: number | null;
    ttlMs: number | null;
    syncing: boolean;
    refreshIntervalMs: number;
    lazyReload: boolean;
    staleWhileRevalidate: boolean;
    redisEnabled: boolean;
    clusterSyncEnabled: boolean;
}
export type CacheManagerEvents = {
    synced: [];
    refreshed: [];
    refreshedItem: [PlainRecord];
    itemCreated: [PlainRecord];
    itemUpdated: [PlainRecord];
    itemRemoved: [PlainRecord];
    itemInvalidated: [{
        field: string;
        value: string | number;
    }];
    cleared: [];
    clearedField: [string];
    error: [Error];
    ready: [];
    redisReconnecting: [{
        attempt: number;
        delay: number;
    }];
    redisReconnected: [];
    redisDisconnected: [];
    evicted: [{
        id: string | number;
        reason: 'lru' | 'size-limit';
    }];
};