import { LRUCache } from 'lru-cache';
import { type SerializableLruOptions, type Stats } from './messages.js';
import { type L1Stats } from './l1.js';
type NonNullish = {};
export interface WriteOptions {
    ttl?: number;
    size?: number;
    updateL1?: boolean;
}
export interface ReadOptions {
    bypassL1?: boolean;
}
export type MSetEntry<K extends {}, V extends {}> = [K, V] | [K, V, WriteOptions];
export interface FetchOptions extends WriteOptions {
    forceRefresh?: boolean;
    bypassL1?: boolean;
}
export type LocalL1Options = {
    enabled?: boolean;
    max?: number;
    maxSize?: number;
    ttl?: number;
    updateAgeOnGet?: boolean;
    allowStale?: boolean;
    cacheUndefined?: boolean;
    invalidation?: 'broadcast' | 'ttl-only';
    methods?: {
        get?: boolean;
        has?: boolean;
        fetch?: boolean;
    };
    experimental?: boolean;
};
export interface LRUCacheClusterOptions extends SerializableLruOptions {
    namespace?: string;
    timeout?: number;
    failsafe?: 'resolve' | 'reject';
    localL1?: false | LocalL1Options;
}
interface InternalOptions {
    noInit?: boolean;
}
export declare class LRUCacheClustered<K extends {} = string, V extends {} = {}> {
    #private;
    readonly namespace: string;
    readonly timeout: number;
    readonly failsafe: 'resolve' | 'reject';
    readonly ready: Promise<void>;
    constructor(options?: LRUCacheClusterOptions & InternalOptions);
    static getInstance<K extends {} = string, V extends {} = {}>(options?: LRUCacheClusterOptions): Promise<LRUCacheClustered<K, V>>;
    static bootstrap(): void;
    static getAllCaches(): Map<string, LRUCache<NonNullish, NonNullish>>;
    getCache(): LRUCache<K & NonNullish, V & NonNullish> | undefined;
    get(key: K, opts?: ReadOptions): Promise<V | undefined>;
    set(key: K, value: V, opts?: WriteOptions): Promise<boolean>;
    delete(key: K): Promise<boolean>;
    has(key: K, opts?: ReadOptions): Promise<boolean>;
    peek(key: K, opts?: ReadOptions): Promise<V | undefined>;
    clear(): Promise<void>;
    purgeStale(): Promise<boolean>;
    mGet(keys: K[], opts?: ReadOptions): Promise<Map<K, V | undefined>>;
    mSet(entries: Iterable<MSetEntry<K, V>>, opts?: WriteOptions): Promise<void>;
    mDelete(keys: K[]): Promise<void>;
    keys(): Promise<K[]>;
    values(): Promise<V[]>;
    entries(): Promise<[K, V][]>;
    dump(): Promise<[K, LRUCache.Entry<V>][]>;
    size(): Promise<number>;
    incr(key: K, amount?: number, opts?: WriteOptions): Promise<number>;
    decr(key: K, amount?: number, opts?: WriteOptions): Promise<number>;
    allowStale(value?: boolean): Promise<boolean>;
    max(value?: number): Promise<number>;
    ttl(value?: number): Promise<number>;
    getRemainingTTL(key: K): Promise<number>;
    setIfAbsent(key: K, value: V, opts?: WriteOptions): Promise<boolean>;
    load(entries: Array<[K, LRUCache.Entry<V>]>): Promise<void>;
    destroy(): Promise<boolean>;
    healthCheck(): Promise<void>;
    stats(): Promise<Stats>;
    localStats(): L1Stats | undefined;
    on(event: string, listener: (...args: unknown[]) => void): this;
    off(event: string, listener: (...args: unknown[]) => void): this;
    once(event: string, listener: (...args: unknown[]) => void): this;
    clearLocal(): void;
    invalidateLocal(key: K): void;
    withoutLocal(): LRUCacheClustered<K, V>;
    [Symbol.asyncIterator](): AsyncIterableIterator<[K, V]>;
    fetch(key: K, fetcher: (key: K) => Promise<V> | V, opts?: FetchOptions): Promise<V>;
}
export { LRUCacheClustered as LRUCacheForClustersAsPromised };
export { memoize, type MemoizeOptions } from './memoize.js';
export { wrap, type Codec, type WrappedCache } from './codec.js';
export default LRUCacheClustered;
//# sourceMappingURL=index.d.ts.map