import Maybe from '../Maybe';
import { Dict as IDict, Key } from './index';
export declare type Cast<K> = K extends string ? string : K extends number ? number : K extends Date ? Date : K;
export declare class Dict<K, T> implements IDict<K, T> {
    private readonly count;
    private readonly root;
    static empty: Dict<unknown, unknown>;
    static singleton<K extends Key, T>(key: K, value: T): Dict<Cast<K>, T>;
    static fromList<K extends Key, T, P>(toKey: (item: P) => K, toValue: (item: P) => T, items: Array<P>): Dict<Cast<K>, T>;
    private constructor();
    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;
}