/**
 * This file contains the ReadonlyMap algebraic data type. ReadonlyMap is a
 * built in data structure in javascript that allows the association of
 * arbitrary key anv value pairs. Generally, keys in a ReadonlyMap are only
 * equal if their memory addresses are equal. This means that while strings and
 * numbers work as expected as keys, complex objects such as [1] or { one: 1 }
 * do not. Thus, there are many utility functions in this file that allow one to
 * specify how to determine equality for keys in a ReadonlyMap.
 *
 * @module ReadonlyMap
 * @since 2.0.0
 */
import "./_dnt.polyfills.js";
import type { Kind, Out } from "./kind.js";
import type { Bimappable } from "./bimappable.js";
import type { Combinable } from "./combinable.js";
import type { Comparable } from "./comparable.js";
import type { Flatmappable } from "./flatmappable.js";
import type { Foldable } from "./foldable.js";
import type { Initializable } from "./initializable.js";
import type { Mappable } from "./mappable.js";
import type { Option } from "./option.js";
import type { Showable } from "./showable.js";
import type { Sortable } from "./sortable.js";
/**
 * @since 2.0.0
 */
export interface KindReadonlyMap extends Kind {
    readonly kind: ReadonlyMap<Out<this, 1>, Out<this, 0>>;
}
/**
 * @since 2.0.0
 */
export interface KindKeyedReadonlyMap<B> extends Kind {
    readonly kind: ReadonlyMap<B, Out<this, 0>>;
}
/**
 * @since 2.0.0
 */
export type TypeOf<U> = U extends ReadonlyMap<infer _, infer A> ? A : never;
/**
 * @since 2.0.0
 */
export type KeyOf<U> = U extends ReadonlyMap<infer B, infer _> ? B : never;
/**
 * @since 2.0.0
 */
export declare function init<K, A>(): ReadonlyMap<K, A>;
/**
 * @since 2.0.0
 */
export declare function singleton<K, A>(k: K, a: A): ReadonlyMap<K, A>;
/**
 * @since 2.0.0
 */
export declare function isEmpty<A, B>(ta: ReadonlyMap<B, A>): boolean;
/**
 * @since 2.0.0
 */
export declare function readonlyMap<K = never, A = never>(...pairs: [K, A][]): ReadonlyMap<K, A>;
/**
 * @since 2.0.0
 */
export declare function map<A, I>(fai: (a: A) => I): <B>(ta: ReadonlyMap<B, A>) => ReadonlyMap<B, I>;
/**
 * @since 2.0.0
 */
export declare function bimap<A, B, I, J>(fbj: (b: B) => J, fai: (a: A) => I): (ta: ReadonlyMap<B, A>) => ReadonlyMap<J, I>;
/**
 * @since 2.0.0
 */
export declare function mapSecond<B, J>(fbj: (b: B) => J): <A>(ta: ReadonlyMap<B, A>) => ReadonlyMap<J, A>;
/**
 * @since 2.0.0
 */
export declare function size<K, A>(d: ReadonlyMap<K, A>): number;
/**
 * @since 2.0.0
 */
export declare function lookupWithKey<K>(S: Comparable<K>): (k: K) => <A>(ta: ReadonlyMap<K, A>) => Option<[K, A]>;
/**
 * @since 2.0.0
 */
export declare function lookup<K>(S: Comparable<K>): (k: K) => <A>(ta: ReadonlyMap<K, A>) => Option<A>;
/**
 * @since 2.0.0
 */
export declare function member<K>(S: Comparable<K>): (k: K) => <A>(ta: ReadonlyMap<K, A>) => boolean;
/**
 * @since 2.0.0
 */
export declare function elem<A>(S: Comparable<A>): (a: A) => <K>(m: ReadonlyMap<K, A>) => boolean;
/**
 * @since 2.0.0
 */
export declare function entries<B>(O: Sortable<B>): <A>(ta: ReadonlyMap<B, A>) => ReadonlyArray<[B, A]>;
/**
 * @since 2.0.0
 */
export declare function keys<K>(O: Sortable<K>): <A>(ta: ReadonlyMap<K, A>) => K[];
/**
 * @since 2.0.0
 */
export declare function values<A>(O: Sortable<A>): <K>(ta: ReadonlyMap<K, A>) => A[];
/**
 * @since 2.0.0
 */
export declare function fold<B, A, O>(foldr: (accumulator: O, value: A, key: B) => O, initial: O): (ua: ReadonlyMap<B, A>) => O;
/**
 * @since 2.0.0
 */
export declare function collect<B>(O: Sortable<B>): <A, I>(fai: (b: B, a: A) => I) => (ta: ReadonlyMap<B, A>) => ReadonlyArray<I>;
/**
 * @since 2.0.0
 */
export declare function deleteAt<B>(S: Comparable<B>): (key: B) => <A>(map: ReadonlyMap<B, A>) => ReadonlyMap<B, A>;
/**
 * @since 2.0.0
 */
export declare function insert<B>(S: Comparable<B>): <A>(value: A) => (key: B) => (map: ReadonlyMap<B, A>) => ReadonlyMap<B, A>;
/**
 * @since 2.0.0
 */
export declare function insertAt<B>(S: Comparable<B>): (key: B) => <A>(value: A) => (map: ReadonlyMap<B, A>) => ReadonlyMap<B, A>;
/**
 * @since 2.0.0
 */
export declare function modify<B>(S: Comparable<B>): <A>(modifyFn: (a: A) => A) => (key: B) => (ta: ReadonlyMap<B, A>) => ReadonlyMap<B, A>;
/**
 * @since 2.0.0
 */
export declare function modifyAt<B>(S: Comparable<B>): (key: B) => <A>(modifyFn: (value: A) => A) => (map: ReadonlyMap<B, A>) => ReadonlyMap<B, A>;
/**
 * @since 2.0.0
 */
export declare function update<B>(S: Comparable<B>): <A>(value: A) => (key: B) => (map: ReadonlyMap<B, A>) => ReadonlyMap<B, A>;
/**
 * @since 2.0.0
 */
export declare function updateAt<B>(S: Comparable<B>): (key: B) => <A>(value: A) => (map: ReadonlyMap<B, A>) => ReadonlyMap<B, A>;
/**
 * @since 2.0.0
 */
export declare function pop<B>(S: Comparable<B>): (b: B) => <A>(ta: ReadonlyMap<B, A>) => Option<[A, ReadonlyMap<B, A>]>;
/**
 * @since 2.0.0
 */
export declare function isSubmap<K, A>(SK: Comparable<K>, SA: Comparable<A>): (second: ReadonlyMap<K, A>) => (first: ReadonlyMap<K, A>) => boolean;
/**
 * @since 2.0.0
 */
export declare function getFlatmappableReadonlyMap<B>({ init, combine }: Initializable<B>): Flatmappable<KindKeyedReadonlyMap<B>>;
/**
 * @since 2.0.0
 */
export declare function getComparable<K, A>(SK: Comparable<K>, SA: Comparable<A>): Comparable<ReadonlyMap<K, A>>;
/**
 * @since 2.0.0
 */
export declare function getCombinable<K, A>(SK: Comparable<K>, SA: Combinable<A>): Combinable<ReadonlyMap<K, A>>;
/**
 * @since 2.0.0
 */
export declare function getShowable<K, A>(SK: Showable<K>, SA: Showable<A>): Showable<ReadonlyMap<K, A>>;
/**
 * @since 2.0.0
 */
export declare const MappableMap: Mappable<KindReadonlyMap>;
/**
 * @since 2.0.0
 */
export declare const BimappableMap: Bimappable<KindReadonlyMap>;
/**
 * @since 2.0.0
 */
export declare const FoldableMap: Foldable<KindReadonlyMap>;