import { IDisposable } from '@phosphor/disposable';
import { ISignal } from '@phosphor/signaling';
/**
 * A map which can be observed for changes.
 */
export interface IObservableMap<T> extends IDisposable {
    /**
     * A signal emitted when the map has changed.
     */
    readonly changed: ISignal<this, ObservableMap.IChangedArgs<T>>;
    /**
     * The number of key-value pairs in the map.
     */
    readonly size: number;
    /**
     * Set a key-value pair in the map
     *
     * @param key - The key to set.
     *
     * @param value - The value for the key.
     *
     * @returns the old value for the key, or undefined
     *   if that did not exist.
     */
    set(key: string, value: T): T;
    /**
     * Get a value for a given key.
     *
     * @param key - the key.
     *
     * @returns the value for that key.
     */
    get(key: string): T;
    /**
     * Check whether the map has a key.
     *
     * @param key - the key to check.
     *
     * @returns `true` if the map has the key, `false` otherwise.
     */
    has(key: string): boolean;
    /**
     * Get a list of the keys in the map.
     *
     * @returns - a list of keys.
     */
    keys(): string[];
    /**
     * Get a list of the values in the map.
     *
     * @returns - a list of values.
     */
    values(): T[];
    /**
     * Remove a key from the map
     *
     * @param key - the key to remove.
     *
     * @returns the value of the given key,
     *   or undefined if that does not exist.
     */
    delete(key: string): T;
    /**
     * Set the ObservableMap to an empty map.
     */
    clear(): void;
    /**
     * Dispose of the resources held by the map.
     */
    dispose(): void;
}
/**
 * A concrete implementation of IObservbleMap<T>.
 */
export declare class ObservableMap<T> implements IObservableMap<T> {
    /**
     * Construct a new observable map.
     */
    constructor(options?: ObservableMap.IOptions<T>);
    /**
     * A signal emitted when the map has changed.
     */
    readonly changed: ISignal<this, ObservableMap.IChangedArgs<T>>;
    /**
     * Whether this map has been disposed.
     */
    readonly isDisposed: boolean;
    /**
     * The number of key-value pairs in the map.
     */
    readonly size: number;
    /**
     * Set a key-value pair in the map
     *
     * @param key - The key to set.
     *
     * @param value - The value for the key.
     *
     * @returns the old value for the key, or undefined
     *   if that did not exist.
     *
     * @throws if the new value is undefined.
     *
     * #### Notes
     * This is a no-op if the value does not change.
     */
    set(key: string, value: T): T;
    /**
     * Get a value for a given key.
     *
     * @param key - the key.
     *
     * @returns the value for that key.
     */
    get(key: string): T;
    /**
     * Check whether the map has a key.
     *
     * @param key - the key to check.
     *
     * @returns `true` if the map has the key, `false` otherwise.
     */
    has(key: string): boolean;
    /**
     * Get a list of the keys in the map.
     *
     * @returns - a list of keys.
     */
    keys(): string[];
    /**
     * Get a list of the values in the map.
     *
     * @returns - a list of values.
     */
    values(): T[];
    /**
     * Remove a key from the map
     *
     * @param key - the key to remove.
     *
     * @returns the value of the given key,
     *   or undefined if that does not exist.
     */
    delete(key: string): T;
    /**
     * Set the ObservableMap to an empty map.
     */
    clear(): void;
    /**
     * Dispose of the resources held by the map.
     */
    dispose(): void;
    private _map;
    private _itemCmp;
    private _changed;
}
/**
 * The namespace for `ObservableMap` class statics.
 */
export declare namespace ObservableMap {
    /**
     * The options used to initialize an observable map.
     */
    interface IOptions<T> {
        /**
         * An optional intial set of values.
         */
        values?: {
            [key: string]: T;
        };
        /**
         * The item comparison function for change detection on `set`.
         *
         * If not given, strict `===` equality will be used.
         */
        itemCmp?: (first: T, second: T) => boolean;
    }
    /**
     * The change types which occur on an observable map.
     */
    type ChangeType = 'add' | 'remove' | 'change';
    /**
     * The changed args object which is emitted by an observable map.
     */
    interface IChangedArgs<T> {
        /**
         * The type of change undergone by the map.
         */
        type: ChangeType;
        /**
         * The key of the change.
         */
        key: string;
        /**
         * The old value of the change.
         */
        oldValue: T;
        /**
         * The new value of the change.
         */
        newValue: T;
    }
}