/**
 * node-internal-cache
 * https://github.com/etroynov/node-internal-cache
 *
 * Released under the MIT license
 * https://github.com/etroynov/node-internal-cache/blob/master/LICENSE
 */
import { EventEmitter } from 'node:events';
export type Key = string | number;
export interface WrappedValue<T> {
    /** absolute expiration timestamp in ms; 0 means never expires */
    t: number;
    /** stored value */
    v: T;
    /** marker so set(key, undefined) round-trips correctly */
    hasValue: boolean;
}
export interface ValueSetItem<T = unknown> {
    key: Key;
    val: T;
    ttl?: number;
}
export interface Stats {
    hits: number;
    misses: number;
    keys: number;
    ksize: number;
    vsize: number;
}
export interface Options {
    forceString?: boolean;
    objectValueSize?: number;
    promiseValueSize?: number;
    arrayValueSize?: number;
    stdTTL?: number;
    checkperiod?: number;
    useClones?: boolean;
    deleteOnExpire?: boolean;
    maxKeys?: number;
}
export interface CacheError extends Error {
    name: string;
    errorcode: string;
    data: {
        type?: string;
    };
}
export type NodeCacheEvents = {
    set: [key: Key, value: unknown];
    del: [key: Key, value: unknown];
    expired: [key: Key, value: unknown];
    miss: [key: Key];
    take: [key: Key, value: unknown];
    flush: [];
    flush_stats: [];
};
interface TypedEventEmitter<E> {
    on<K extends keyof E & string>(event: K, listener: (...args: E[K] extends unknown[] ? E[K] : never) => void): this;
    once<K extends keyof E & string>(event: K, listener: (...args: E[K] extends unknown[] ? E[K] : never) => void): this;
    off<K extends keyof E & string>(event: K, listener: (...args: E[K] extends unknown[] ? E[K] : never) => void): this;
    emit<K extends keyof E & string>(event: K, ...args: E[K] extends unknown[] ? E[K] : never): boolean;
}
declare const NodeCache_base: new () => EventEmitter & TypedEventEmitter<NodeCacheEvents>;
declare class NodeCache extends NodeCache_base {
    /** Cache storage */
    data: Map<Key, WrappedValue<unknown>>;
    /** Statistics container */
    stats: Stats;
    /** Resolved options */
    options: Required<Options>;
    private checkTimeout;
    private inflight;
    constructor(options?: Options);
    get<T = unknown>(key: Key): T | undefined;
    mget<T = unknown>(keys: Key[]): Record<string, T>;
    set<T = unknown>(key: Key, value: T, ttl?: number): boolean;
    fetch<T = unknown>(key: Key, ttlOrValue: number | T | (() => T), maybeValue?: T | (() => T)): T;
    fetchAsync<T>(key: Key, ttlOrFn: number | (() => Promise<T> | T), maybeFn?: () => Promise<T> | T): Promise<T>;
    mset<T = unknown>(keyValueSet: ValueSetItem<T>[]): boolean;
    del(keys: Key | Key[]): number;
    take<T = unknown>(key: Key): T | undefined;
    ttl(key: Key, ttl?: number): boolean;
    getTtl(key: Key): number | undefined;
    keys(): string[];
    has(key: Key): boolean;
    getStats(): Stats;
    flushAll(startPeriod?: boolean): void;
    flushStats(): void;
    close(): void;
    _checkData(startPeriod?: boolean): void;
    _killCheckPeriod(): void;
    /**
     * Returns the entry if it exists and has not expired (taking
     * `deleteOnExpire` into account); otherwise returns `undefined`.
     * Centralises the "lookup + expiry handling" path used by get/has/take/etc.
     */
    private _liveEntry;
    private _check;
    private _isInvalidKey;
    private _assertKey;
    private _assertTtl;
    /**
     * Convert a relative TTL (in seconds) into an absolute expiry timestamp.
     * `undefined` falls back to `stdTTL`. Returns `0` when the entry should
     * never expire.
     */
    private _resolveExpiry;
    private _parseFetchArgs;
    private _wrap;
    private _unwrap;
    private _getKeyLength;
    private _getValLength;
    private _error;
}
export default NodeCache;