import type { Expression, FilterConfig } from '../../types';
interface MemoizationCache<R> {
    get(key: string): R | undefined;
    set(key: string, value: R): void;
    clear(): void;
    size(): number;
}
export declare class LRUCache<R> implements MemoizationCache<R> {
    private cache;
    private maxSize;
    private maxAge;
    constructor(maxSize?: number, maxAge?: number);
    get(key: string): R | undefined;
    set(key: string, value: R): void;
    clear(): void;
    size(): number;
}
export declare class MemoizationManager {
    private static instance;
    private predicateCache;
    private regexCache;
    private expressionHashCache;
    private constructor();
    static getInstance(): MemoizationManager;
    createExpressionHash<T>(expression: Expression<T>, config: FilterConfig): string;
    private hashObject;
    private hashOrderBy;
    private hashValue;
    getCachedPredicate<T>(key: string): ((item: T) => boolean) | undefined;
    setCachedPredicate<T>(key: string, predicate: (item: T) => boolean): void;
    getCachedRegex(pattern: string, flags?: string): RegExp | undefined;
    setCachedRegex(pattern: string, regex: RegExp, flags?: string): void;
    clearPredicateCache(): void;
    clearRegexCache(): void;
    clearAll(): void;
    getStats(): CacheStats;
}
export declare const memoization: MemoizationManager;
export interface CacheStats {
    predicateCacheSize: number;
    regexCacheSize: number;
}
export {};