import { Comparable } from '../Basics';
import Maybe from '../Maybe';
import { Cast } from './Dict';
export interface Dict<K, T> {
    get(key: K): Maybe<T>;
    min(): Maybe<[K, T]>;
    max(): Maybe<[K, T]>;
    member(key: K): boolean;
    insert(key: K, value: T): Dict<K, T>;
    remove(key: K): Dict<K, T>;
    update(key: K, fn: (value: Maybe<T>) => Maybe<T>): Dict<K, T>;
    size(): number;
    isEmpty(): boolean;
    map<R>(fn: (key: K, value: T) => R): Dict<K, R>;
    filter(fn: (key: K, value: T) => boolean): Dict<K, T>;
    partition(fn: (key: K, value: T) => boolean): [Dict<K, T>, Dict<K, T>];
    foldl<R>(fn: (key: K, value: T, acc: R) => R, acc: R): R;
    foldr<R>(fn: (key: K, value: T, acc: R) => R, acc: R): R;
    union(another: Dict<K, T>): Dict<K, T>;
    intersect(another: Dict<K, T>): Dict<K, T>;
    diff(another: Dict<K, T>): Dict<K, T>;
    merge<D, R>(onLeft: (key: K, left: T, acc: R) => R, onBoth: (key: K, left: T, right: D, acc: R) => R, onRight: (key: K, right: D, acc: R) => R, right: Dict<K, D>, acc: R): R;
    keys(): Array<K>;
    values(): Array<T>;
    entries(): Array<[K, T]>;
    tap<R>(fn: (that: Dict<K, T>) => R): R;
}
export declare namespace Dict {
    type Key = string | number | Date | Comparable<unknown>;
    const empty: Dict<unknown, unknown>;
    const singleton: <K extends Key, T>(key: K, value: T) => Dict<Cast<K>, T>;
    function fromList<K extends Key, T>(pairs: Array<[K, T]>): Dict<Cast<K>, T>;
    function fromList<K extends Key, T, P>(toKey: (item: P) => K, toValue: (item: P) => T, items: Array<P>): Dict<Cast<K>, T>;
}
export declare type Key = Dict.Key;
export declare const empty: Dict<unknown, unknown>;
export declare const singleton: <K extends Dict.Key, T>(key: K, value: T) => Dict<Cast<K>, T>;
export declare const fromList: typeof Dict.fromList;
export default Dict;