export type Options<KeyType, ValueType> = {
    /**
      The maximum number of milliseconds an item should remain in the cache.
  
      @defaultValue Infinity
  
      By default, `maxAge` will be `Infinity`, which means that items will never expire.
      Lazy expiration upon the next write or read call.
  
      Individual expiration of an item can be specified by the `set(key, value, maxAge)` method.
      */
    maxAge?: number;
    /**
      The maximum number of items before evicting the least recently used items.
      */
    maxSize: number;
    /**
      Called right before an item is evicted from the cache.
  
      Useful for side effects or for items like object URLs that need explicit cleanup (`revokeObjectURL`).
      */
    onEviction?: (key: KeyType, value: ValueType) => void;
};
export type CacheValue<ValueType> = {
    value: ValueType;
    expiry?: number;
};
export declare class QuickLRU<KeyType, ValueType> extends Map<KeyType, ValueType> implements Iterable<[KeyType, ValueType]> {
    #private;
    /**
      Simple ["Least Recently Used" (LRU) cache](https://en.m.wikipedia.org/wiki/Cache_replacement_policies#Least_Recently_Used_.28LRU.29).
  
      The instance is an [`Iterable`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols) of `[key, value]` pairs so you can use it directly in a [`for…of`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/for...of) loop.
      */
    constructor(options: Options<KeyType, ValueType>);
    get __oldCache(): Map<KeyType, CacheValue<ValueType>>;
    /**
      Get an item.
  
      @returns The stored item or `undefined`.
      */
    get(key: KeyType): ValueType | undefined;
    /**
      Set an item. Returns the instance.
  
      Individual expiration of an item can be specified with the `maxAge` option. If not specified, the global `maxAge` value will be used in case it is specified in the constructor, otherwise the item will never expire.
  
      @returns The list instance.
      */
    set(key: KeyType, value: ValueType, options?: {
        maxAge?: number;
    }): this;
    has(key: KeyType): boolean;
    peek(key: KeyType): ValueType | undefined;
    delete(key: KeyType): boolean;
    clear(): void;
    /**
      Update the `maxSize` in-place, discarding items as necessary. Insertion order is mostly preserved, though this is not a strong guarantee.
  
      Useful for on-the-fly tuning of cache sizes in live systems.
      */
    resize(newSize: number): void;
    /**
      Iterable for all the keys.
      */
    keys(): IterableIterator<KeyType>;
    /**
      Iterable for all the values.
      */
    values(): IterableIterator<ValueType>;
    [Symbol.iterator](): IterableIterator<[KeyType, ValueType]>;
    /**
      Iterable for all entries, starting with the newest (descending in recency).
      */
    entriesDescending(): IterableIterator<[KeyType, ValueType]>;
    /**
      Iterable for all entries, starting with the oldest (ascending in recency).
      */
    entriesAscending(): IterableIterator<[KeyType, ValueType]>;
    get size(): number;
    get maxSize(): number;
    entries(): IterableIterator<[KeyType, ValueType]>;
    forEach(callbackFunction: (value: ValueType, key: KeyType, thisArg: this) => void, thisArgument?: this): void;
    get [Symbol.toStringTag](): string;
}