import type { CacheEntry } from './domain/CacheEntry';
import type { CacheInfo } from './domain/CacheInfo';
import type { MemorizeBatchOptions } from './domain/MemorizeBatchOptions';
import type { MemorizeDeleteEvent } from './domain/MemorizeDeleteEvent';
import type { MemorizeEmptyEvent } from './domain/MemorizeEmptyEvent';
import { MemorizeEventType } from './domain/MemorizeEventType';
import type { MemorizeEvictEvent } from './domain/MemorizeEvictEvent';
import type { MemorizeExpireEvent } from './domain/MemorizeExpireEvent';
import type { MemorizeInspectionOptions, MemorizeInspectionPage } from './domain/MemorizeInspection';
import type { MemorizeSetEvent } from './domain/MemorizeSetEvent';
import type { MemorizeStats } from './domain/MemorizeStats';
import type { MemorizeStoreLike, MemorizeStoreOptions, StoreEntryInput } from './MemorizeStoreLike';
export declare const SQLITE_STORAGE_WARNING = "[express-memorize] SQLite storage requires Node.js 24 or newer. Falling back to in-memory storage.";
export interface SqliteMemorizeStoreOptions extends MemorizeStoreOptions {
    directory?: string;
}
export declare function canUseNativeSqlite(): boolean;
export declare class SqliteMemorizeStore implements MemorizeStoreLike {
    private readonly _db;
    private readonly _statements;
    private readonly _maxEntries?;
    private readonly _maxValueBytes?;
    private readonly _maxTotalBytes?;
    private readonly _sizeLimitAction;
    private _accessCounter;
    private _hits;
    private _misses;
    private _expiryTimer;
    private _nextExpiryAt;
    private _nextExpiryKey;
    private _listeners;
    constructor(options?: SqliteMemorizeStoreOptions);
    /** Adds columns introduced after the first release to databases created by older versions. */
    private _migrate;
    on(event: MemorizeEventType.Set, handler: (e: MemorizeSetEvent) => void): () => void;
    on(event: MemorizeEventType.Delete, handler: (e: MemorizeDeleteEvent) => void): () => void;
    on(event: MemorizeEventType.Expire, handler: (e: MemorizeExpireEvent) => void): () => void;
    on(event: MemorizeEventType.Empty, handler: (e: MemorizeEmptyEvent) => void): () => void;
    on(event: MemorizeEventType.Evict, handler: (e: MemorizeEvictEvent) => void): () => void;
    off(event: MemorizeEventType.Set, handler: (e: MemorizeSetEvent) => void): void;
    off(event: MemorizeEventType.Delete, handler: (e: MemorizeDeleteEvent) => void): void;
    off(event: MemorizeEventType.Expire, handler: (e: MemorizeExpireEvent) => void): void;
    off(event: MemorizeEventType.Empty, handler: (e: MemorizeEmptyEvent) => void): void;
    off(event: MemorizeEventType.Evict, handler: (e: MemorizeEvictEvent) => void): void;
    private _off;
    set(key: string, entry: StoreEntryInput, ttl?: number | null): void;
    get(key: string): CacheInfo | null;
    getAll(): Record<string, CacheInfo>;
    getAllAsync(options?: MemorizeBatchOptions): Promise<Record<string, CacheInfo>>;
    inspectAsync(options?: MemorizeInspectionOptions): Promise<MemorizeInspectionPage>;
    delete(key: string): boolean;
    deleteMatching(pattern: string): number;
    deleteMatchingAsync(pattern: string, options?: MemorizeBatchOptions): Promise<number>;
    deleteByTag(tag: string | string[]): number;
    deleteByTagAsync(tag: string | string[], options?: MemorizeBatchOptions): Promise<number>;
    clear(): void;
    clearAsync(options?: MemorizeBatchOptions): Promise<number>;
    size(): number;
    byteSize(): number;
    getStats(): MemorizeStats;
    getRaw(key: string): CacheEntry | null;
    private _getActiveEntry;
    private _prepare;
    private _getRow;
    private _hasRow;
    private _rowToEntry;
    private _keys;
    private _countRows;
    private _sumByteSize;
    private _maxLastAccessed;
    private _nextAccessed;
    private _deleteRow;
    private _canStoreSize;
    private _evictLRU;
    private _evict;
    private _scheduleNextExpiry;
    private _scheduleExpiryFor;
    private _scheduleExpiryAt;
    private _clearExpiryTimer;
    private _evictExpiredEntries;
    private _evictExpiredEntry;
    /**
     * Releases all resources held by the store: cancels the expiry timer, drops
     * every listener, and closes the underlying SQLite database. Persisted
     * entries are kept on disk. The store must not be used after disposal.
     */
    dispose(): void;
    private _emit;
    private _format;
}
//# sourceMappingURL=SqliteMemorizeStore.d.ts.map