import { MapItems } from "./Collection";
import Iterator from "./Iterator";
export declare class Entry<K = string | number, V = any> {
    constructor(key: K, value: V);
    private _key;
    readonly key: K;
    private _value;
    readonly value: V;
}
export default class Map<K extends string | number, V = any> {
    private _items;
    /**
     *
     */
    constructor(map?: Map<K, V> | MapItems<V> | Array<V>);
    private _length;
    /**
     *  Returns the number of key-value mappings in this map.
     * @returns {number}map
     */
    readonly length: number;
    /**
     * Returns <tt>true</tt> if this map contains no key-value mappings.
     * @return
     */
    isEmpty(): boolean;
    /**
     *
     * @param {K} key
     * @returns {boolean}
     */
    containsKey(key: K): boolean;
    /**
     *
     * @param {V} value
     * @returns {boolean}
     */
    containsValue(value: V): boolean;
    /**
     *
     * @param {K} key
     * @returns {V}
     */
    get(key: K): V;
    /**
     *
     * @param {K} key
     * @param {V} def
     * @returns {V}
     */
    getOrDefault(key: K, def: V): V;
    /**
     *
     * @param {K} key
     * @param {V} value
     * @returns {V}
     */
    put(key: K, value: V): V;
    /**
     *
     * @param {K} key
     * @returns {boolean}
     */
    remove(key: K): boolean;
    /**
     *
     * @param {Map<K, V> | MapItems<V> | Array<V>} map
     */
    putAll(map: Map<K, V> | MapItems<V> | Array<V>): Array<V>;
    /**
     *
     */
    clear(): void;
    /**
     *
     * @returns {Array<K>}
     */
    keySet(): Array<K>;
    /**
     *
     * @returns {Array<V>}
     */
    values(): Array<V>;
    /**
     *
     * @returns {Array<Entry<K, V>>}
     */
    entrySet(): Array<Entry<K, V>>;
    /**
     *
     * @param {(item: V, key?: K) => boolean} callback
     * @returns {boolean}
     */
    forEach<T = string | number>(callback: (item: V, key?: K) => void | boolean): boolean;
    /**
     *
     * @param {(item: V, key?: K, obj?: V) => T} callback
     * @returns {Array<T>}
     */
    map<U>(callback: (value: V, key: K) => U): Array<U>;
    /**
     *
     * @param {(entry: Entry<K, V>) => boolean} predicate
     * @returns {Map<K extends string | number, V>}
     */
    filter<U>(predicate: (entry: Entry<K, V>) => boolean): Map<K, V>;
    iterator(): Iterator<Entry<K, V>>;
    private add;
}