import { AbstractCache } from './AbstractCache';
import { Cache } from './Cache';
import { CacheSPI } from './CacheSPI';
import { KeyType } from './KeyType';
import { Metrics } from './metrics/Metrics';
import { RemovalListener } from './RemovalListener';
import { ON_REMOVE, ON_MAINTENANCE, TRIGGER_REMOVE } from './symbols';
declare const PARENT: unique symbol;
declare const REMOVAL_LISTENER: unique symbol;
/**
 * Wrapper for another cache, used to extend that cache with new behavior,
 * like for loading things or collecting metrics.
 */
export declare abstract class WrappedCache<K extends KeyType, V> extends AbstractCache<K, V> implements Cache<K, V>, CacheSPI<K, V> {
    private [PARENT];
    [ON_REMOVE]?: RemovalListener<K, V>;
    private [REMOVAL_LISTENER];
    constructor(parent: Cache<K, V> & CacheSPI<K, V>, removalListener: RemovalListener<K, V> | null);
    /**
     * The maximum size the cache can be. Will be -1 if the cache is unbounded.
     *
     * @returns
     *   maximum size
     */
    get maxSize(): number;
    /**
     * The current size of the cache.
     *
     * @returns
     *   current size
     */
    get size(): number;
    /**
     * The size of the cache weighted via the activate estimator.
     *
     * @returns
     *   current weighted size
     */
    get weightedSize(): number;
    /**
     * Store a value tied to the specified key. Returns the previous value or
     * `null` if no value currently exists for the given key.
     *
     * @param key -
     *   key to store value under
     * @param value -
     *   value to store
     * @returns
     *   current value or `null`
     */
    set(key: K, value: V): V | null;
    /**
     * Get the cached value for the specified key if it exists. Will return
     * the value or `null` if no cached value exist. Updates the usage of the
     * key.
     *
     * @param key -
     *   key to get
     * @returns
     *   current value or `null`
     */
    getIfPresent(key: K): V | null;
    /**
     * Peek to see if a key is present without updating the usage of the
     * key. Returns the value associated with the key or `null`  if the key
     * is not present.
     *
     * In many cases `has(key)` is a better option to see if a key is present.
     *
     * @param key -
     *   the key to check
     * @returns
     *   value associated with key or `null`
     */
    peek(key: K): V | null;
    /**
     * Check if the given key exists in the cache.
     *
     * @param key -
     *   key to check
     * @returns
     *   `true` if value currently exists, `false` otherwise
     */
    has(key: K): boolean;
    /**
     * Delete a value in the cache. Returns the deleted value or `null` if
     * there was no value associated with the key in the cache.
     *
     * @param key -
     *   the key to delete
     * @returns
     *   deleted value or `null`
     */
    delete(key: K): V | null;
    /**
     * Clear the cache removing all of the entries cached.
     */
    clear(): void;
    /**
     * Get all of the keys in the cache as an array. Can be used to iterate
     * over all of the values in the cache, but be sure to protect against
     * values being removed during iteration due to time-based expiration if
     * used.
     *
     * @returns
     *   snapshot of keys
     */
    keys(): K[];
    /**
     * Request clean up of the cache by removing expired entries and
     * old data. Clean up is done automatically a short time after sets and
     * deletes, but if your cache uses time-based expiration and has very
     * sporadic updates it might be a good idea to call `cleanUp()` at times.
     *
     * A good starting point would be to call `cleanUp()` in a `setInterval`
     * with a delay of at least a few minutes.
     */
    cleanUp(): void;
    /**
     * Get metrics for this cache. Returns an object with the keys `hits`,
     * `misses` and `hitRate`. For caches that do not have metrics enabled
     * trying to access metrics will throw an error.
     *
     * @returns
     *   metrics
     */
    get metrics(): Metrics;
    get [ON_MAINTENANCE](): (() => void) | undefined;
    set [ON_MAINTENANCE](listener: (() => void) | undefined);
    private [TRIGGER_REMOVE];
}
export {};