/**  * Config for the leaf and storage cache strategies.  */ type StrategyConfig<K, V> = { leafStrategyClass: CacheStrategyClass<K | LeafStorage<K, V>>; storageStrategyClass: CacheStrategyClass<NestedStorage<K, V>>; }; /**  * Storage callbacks.  */ interface StorageParams<K, V> { /**  * Callback to be called on the storage creation.  * @param storage  */ onCreateStorage?: (storage: Storage<K, V>) => void; /**  * Callback to be called on the storage removal.  * @param storage  */ onRemoveStorage?: (storage: Storage<K, V>) => void; } /**  * Leaf storage callbacks.  */ interface LeafStorageParams<K, V> extends StorageParams<K, V> { /** Callback to be called on the leaf creation */ onCreateLeaf?: (leafKey: K) => void; /** Callback to be called on the leaf removal */ onRemoveLeaf?: (leafKey: K) => void; } /** Parameters for the `UnifiedStorage` */ interface UnifiedStorageParams<K, V> extends StorageParams<K, V> { /** Denotes if the object storage must be used for values with primitive keys */ useObjectStorage?: boolean; /** Denotes if the weak storage must be used for values with non-primitive keys */ useWeakStorage?: boolean; } /**  * Params for the storage context.  */ interface Params<K, V> extends UnifiedStorageParams<K, V>, LeafStorageParams<K, V>, StorageParams<K, V> { /**  * Total limit for the storages (cache nodes).  */ totalStoragesLimit?: number; /**  * Total limit for the leaves (cache entries). Default is 10000.  */ totalLeavesLimit?: number; /**  * Limit of the leaves per a single leaf storage.  */ leavesPerStorageLimit?: number; /**  * Total limit of the leaf storages.  */ totalLeafStoragesLimit?: number; /**  * Either strategy class or different strategy classes for leaves and storage nodes.  */ strategy?: StrategyConfig<K, V> | CacheStrategyClass<unknown>; } /** Params interface extended with optional length and checkLast flag */ interface ParamsWithLength<K, V> extends Params<K, V> { /** Overrides function length */ length?: number; /** Check last arguments or not (default to `true`) */ checkLast?: boolean; } /**  * Memoizes provided function returning wrapped version of it.  * Result function will return value without calling the supplied function if it's present in the cache for the supplied arguments according to `Same-value-zero` algorithm.  * If no value is found, the underlying function will be called with provided arguments.  * @param func  * @param params  */ declare function memoize<V>( func: (...args: any[]) => V, { length, checkLast, ...params }?: ParamsWithLength<any, V> ): typeof func & { recomputations: number; };