import { EventEmitter } from "events";
import { Model } from "sequelize";
import { CacheManagerOptions, PlainRecord } from "./types";
interface SequelizeModel<T extends Model = any> {
    name: string;
    findByPk(pk: any): Promise<T | null>;
    findAll(options?: any): Promise<T[]>;
    findOne(options?: any): Promise<T | null>;
    addHook(...args: any[]): any;
    removeHook(...args: any[]): any;
    getAttributes?: () => Record<string, any>;
}
export declare class CacheManager<T extends Model> extends EventEmitter {
    private model;
    private keyFields;
    private refreshIntervalMs;
    private ttlMs;
    private cleanupIntervalMs;
    private lazyReload;
    private staleWhileRevalidate;
    private logger;
    private redisClient;
    private redisSubscriber;
    private redisKeyPrefix;
    private redisEnabled;
    private clusterSyncEnabled;
    private maxSize;
    private cache;
    private lruOrder;
    private metrics;
    private refreshTimer;
    private cleanupTimer;
    private syncing;
    private loadingPromises;
    private lastSyncAt;
    private lastAutoSync;
    private minAutoSyncInterval;
    private readyPromise;
    private ready;
    constructor(model: typeof Model & SequelizeModel<T>, options?: CacheManagerOptions<T>);
    private _initRedis;
    private _initClusterSync;
    private _instanceId;
    private _getExpiryTime;
    private _deepClone;
    private _updateLRU;
    private _evictLRU;
    private _setItem;
    private _removeById;
    private _removeByKey;
    private _removeItem;
    private _cleanupExpired;
    startCleanup(): void;
    stopCleanup(): void;
    private _lazyLoadById;
    private _lazyLoadByKey;
    getById(id: string | number): Promise<any>;
    getByKey(field: string, value: string | number): Promise<any>;
    getAll(): PlainRecord[];
    clear(field?: string): Promise<void>;
    sync(incremental?: boolean): Promise<void>;
    attachHooks(): void;
    detachHooks(): void;
    autoLoad(): Promise<void>;
    waitUntilReady(): Promise<void>;
    isReady(): boolean;
    startAutoRefresh(): void;
    stopAutoRefresh(): void;
    destroy(): Promise<void>;
    refresh(forceFull?: boolean): Promise<void>;
    handleProcessSignals(): void;
    invalidate(field: string, value: string | number): void;
    has(field: string, value: string | number): boolean;
    hasById(id: string | number): boolean;
    isExpired(id: string | number): boolean;
    getStats(): {
        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;
    };
    size(): number;
    toJSON(includeMeta?: boolean): PlainRecord[] | {
        data: PlainRecord;
        expiresAt: number;
    }[];
    loadFromJSON(arr: PlainRecord[] | Array<{
        data: PlainRecord;
        expiresAt: number;
    }>, hasMeta?: boolean): void;
    preload(source: () => Promise<PlainRecord[]>): Promise<void>;
    dump(limit?: number): {
        id: string;
        keys: string[];
        expiresAt: number;
        expired: boolean;
        data: PlainRecord;
    }[];
    getManyByKey(field: string, values: Array<string | number>): Promise<Record<string, PlainRecord | null>>;
}
export {};