/**
 * @since 1.0.0
 */
import type { Option } from "@fp-ts/core/Option";
import type { Predicate, Refinement } from "@fp-ts/core/Predicate";
import type { Equal } from "@fp-ts/data/Equal";
import type { HashSet } from "@fp-ts/data/HashSet";
import type { UpdateFn } from "@fp-ts/data/internal/HashMap/node";
declare const TypeId: unique symbol;
/**
 * @since 1.0.0
 * @category symbol
 */
export type TypeId = typeof TypeId;
/**
 * @since 1.0.0
 * @category models
 */
export interface HashMap<Key, Value> extends Iterable<readonly [Key, Value]>, Equal {
    readonly _id: TypeId;
}
/**
 * @since 1.0.0
 * @category refinements
 */
export declare const isHashMap: {
    <K, V>(u: Iterable<readonly [K, V]>): u is HashMap<K, V>;
    (u: unknown): u is HashMap<unknown, unknown>;
};
/**
 * Creates a new `HashMap`.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const empty: <K = never, V = never>() => HashMap<K, V>;
/**
 * Constructs a new `HashMap` from an array of key/value pairs.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const make: <Entries extends ReadonlyArray<readonly [any, any]>>(...entries: Entries) => HashMap<Entries[number] extends readonly [infer K, any] ? K : never, Entries[number] extends readonly [any, infer V] ? V : never>;
/**
 * Constructs a new `HashMap` from an iterable of key/value pairs.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const fromIterable: <K, V>(entries: Iterable<readonly [K, V]>) => HashMap<K, V>;
/**
 * Checks if the `HashMap` contains any entries.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const isEmpty: <K, V>(self: HashMap<K, V>) => boolean;
/**
 * Safely lookup the value for the specified key in the `HashMap` using the
 * internal hashing function.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const get: {
    <K, V, K1>(self: HashMap<K, V>, key: K1): Option<V>;
    <K1>(key: K1): <K, V>(self: HashMap<K, V>) => Option<V>;
};
/**
 * Lookup the value for the specified key in the `HashMap` using a custom hash.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const getHash: {
    <K, V, K1>(self: HashMap<K, V>, key: K1, hash: number): Option<V>;
    <K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => Option<V>;
};
/**
 * Unsafely lookup the value for the specified key in the `HashMap` using the
 * internal hashing function.
 *
 * @since 1.0.0
 * @category unsafe
 */
export declare const unsafeGet: {
    <K, V, K1>(self: HashMap<K, V>, key: K1): V;
    <K1>(key: K1): <K, V>(self: HashMap<K, V>) => V;
};
/**
 * Checks if the specified key has an entry in the `HashMap`.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const has: {
    <K, V, K1>(self: HashMap<K, V>, key: K1): boolean;
    <K1>(key: K1): <K, V>(self: HashMap<K, V>) => boolean;
};
/**
 * Checks if the specified key has an entry in the `HashMap` using a custom
 * hash.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const hasHash: {
    <K, V, K1>(self: HashMap<K, V>, key: K1, hash: number): boolean;
    <K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => boolean;
};
/**
 * Sets the specified key to the specified value using the internal hashing
 * function.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const set: {
    <K, V>(self: HashMap<K, V>, key: K, value: V): HashMap<K, V>;
    <K, V>(key: K, value: V): (self: HashMap<K, V>) => HashMap<K, V>;
};
/**
 * Returns an `IterableIterator` of the keys within the `HashMap`.
 *
 * @since 1.0.0
 * @category getters
 */
export declare const keys: <K, V>(self: HashMap<K, V>) => IterableIterator<K>;
/**
 * Returns a `HashSet` of keys within the `HashMap`.
 *
 * @since 1.0.0
 * @category getter
 */
export declare const keySet: <K, V>(self: HashMap<K, V>) => HashSet<K>;
/**
 * Returns an `IterableIterator` of the values within the `HashMap`.
 *
 * @since 1.0.0
 * @category getters
 */
export declare const values: <K, V>(self: HashMap<K, V>) => IterableIterator<V>;
/**
 * Returns the number of entries within the `HashMap`.
 *
 * @since 1.0.0
 * @category getters
 */
export declare const size: <K, V>(self: HashMap<K, V>) => number;
/**
 * Marks the `HashMap` as mutable.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const beginMutation: <K, V>(self: HashMap<K, V>) => HashMap<K, V>;
/**
 * Marks the `HashMap` as immutable.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const endMutation: <K, V>(self: HashMap<K, V>) => HashMap<K, V>;
/**
 * Mutates the `HashMap` within the context of the provided function.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const mutate: {
    <K, V>(self: HashMap<K, V>, f: (self: HashMap<K, V>) => void): HashMap<K, V>;
    <K, V>(f: (self: HashMap<K, V>) => void): (self: HashMap<K, V>) => HashMap<K, V>;
};
/**
 * Set or remove the specified key in the `HashMap` using the specified
 * update function. The value of the specified key will be computed using the
 * provided hash.
 *
 * The update function will be invoked with the current value of the key if it
 * exists, or `None` if no such value exists.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const modifyAt: {
    <K, V>(self: HashMap<K, V>, key: K, f: UpdateFn<V>): HashMap<K, V>;
    <K, V>(key: K, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>;
};
/**
 * Alter the value of the specified key in the `HashMap` using the specified
 * update function. The value of the specified key will be computed using the
 * provided hash.
 *
 * The update function will be invoked with the current value of the key if it
 * exists, or `None` if no such value exists.
 *
 * This function will always either update or insert a value into the `HashMap`.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const modifyHash: {
    <K, V>(self: HashMap<K, V>, key: K, hash: number, f: UpdateFn<V>): HashMap<K, V>;
    <K, V>(key: K, hash: number, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>;
};
/**
 * Updates the value of the specified key within the `HashMap` if it exists.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const modify: {
    <K, V>(self: HashMap<K, V>, key: K, f: (v: V) => V): HashMap<K, V>;
    <K, V>(key: K, f: (v: V) => V): (self: HashMap<K, V>) => HashMap<K, V>;
};
/**
 * Performs a union of this `HashMap` and that `HashMap`.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const union: {
    <K0, V0, K1, V1>(self: HashMap<K0, V0>, that: HashMap<K1, V1>): HashMap<K0 | K1, V0 | V1>;
    <K1, V1>(that: HashMap<K1, V1>): <K0, V0>(self: HashMap<K0, V0>) => HashMap<K1 | K0, V1 | V0>;
};
/**
 * Remove the entry for the specified key in the `HashMap` using the internal
 * hashing function.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const remove: {
    <K, V>(self: HashMap<K, V>, key: K): HashMap<K, V>;
    <K>(key: K): <V>(self: HashMap<K, V>) => HashMap<K, V>;
};
/**
 * Removes all entries in the `HashMap` which have the specified keys.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const removeMany: {
    <K, V>(self: HashMap<K, V>, keys: Iterable<K>): HashMap<K, V>;
    <K>(keys: Iterable<K>): <V>(self: HashMap<K, V>) => HashMap<K, V>;
};
/**
 * Maps over the values of the `HashMap` using the specified function.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const map: {
    <K, V, A>(self: HashMap<K, V>, f: (value: V) => A): HashMap<K, A>;
    <V, A>(f: (value: V) => A): <K>(self: HashMap<K, V>) => HashMap<K, A>;
};
/**
 * Maps over the entries of the `HashMap` using the specified function.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapWithIndex: {
    <K, V, A>(self: HashMap<K, V>, f: (value: V, key: K) => A): HashMap<K, A>;
    <A, V, K>(f: (value: V, key: K) => A): (self: HashMap<K, V>) => HashMap<K, A>;
};
/**
 * Chains over the values of the `HashMap` using the specified function.
 *
 * **NOTE**: the hash and equal of both maps have to be the same.
 *
 * @since 1.0.0
 * @category sequencing
 */
export declare const flatMap: {
    <K, A, B>(self: HashMap<K, A>, f: (value: A) => HashMap<K, B>): HashMap<K, B>;
    <K, A, B>(f: (value: A) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>;
};
/**
 * Chains over the entries of the `HashMap` using the specified function.
 *
 * **NOTE**: the hash and equal of both maps have to be the same.
 *
 * @since 1.0.0
 * @category sequencing
 */
export declare const flatMapWithIndex: {
    <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => HashMap<K, B>): HashMap<K, B>;
    <A, K, B>(f: (value: A, key: K) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>;
};
/**
 * Applies the specified function to the values of the `HashMap`.
 *
 * @since 1.0.0
 * @category traversing
 */
export declare const forEach: {
    <K, V>(self: HashMap<K, V>, f: (value: V) => void): void;
    <V>(f: (value: V) => void): <K>(self: HashMap<K, V>) => void;
};
/**
 * Applies the specified function to the entries of the `HashMap`.
 *
 * @since 1.0.0
 * @category traversing
 */
export declare const forEachWithIndex: {
    <V, K>(self: HashMap<K, V>, f: (value: V, key: K) => void): void;
    <V, K>(f: (value: V, key: K) => void): (self: HashMap<K, V>) => void;
};
/**
 * Reduces the specified state over the values of the `HashMap`.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const reduce: {
    <K, V, Z>(self: HashMap<K, V>, z: Z, f: (z: Z, v: V) => Z): Z;
    <V, Z>(z: Z, f: (z: Z, v: V) => Z): <K>(self: HashMap<K, V>) => Z;
};
/**
 * Reduces the specified state over the entries of the `HashMap`.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const reduceWithIndex: {
    <Z, V, K>(self: HashMap<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z;
    <Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: HashMap<K, V>) => Z;
};
/**
 * Filters entries out of a `HashMap` using the specified predicate.
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const filter: {
    <K, A, B extends A>(self: HashMap<K, A>, f: Refinement<A, B>): HashMap<K, B>;
    <K, A>(self: HashMap<K, A>, f: Predicate<A>): HashMap<K, A>;
    <A, B extends A>(f: Refinement<A, B>): <K>(self: HashMap<K, A>) => HashMap<K, B>;
    <A>(f: Predicate<A>): <K>(self: HashMap<K, A>) => HashMap<K, A>;
};
/**
 * Filters entries out of a `HashMap` using the specified predicate.
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const filterWithIndex: {
    <K, A, B extends A>(self: HashMap<K, A>, f: (a: A, k: K) => a is B): HashMap<K, B>;
    <K, A>(self: HashMap<K, A>, f: (a: A, k: K) => boolean): HashMap<K, A>;
    <K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>;
    <K, A>(f: (a: A, k: K) => boolean): (self: HashMap<K, A>) => HashMap<K, A>;
};
/**
 * Filters out `None` values from a `HashMap` of `Options`s.
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const compact: <K, A>(self: HashMap<K, Option<A>>) => HashMap<K, A>;
/**
 * Maps over the values of the `HashMap` using the specified partial function
 * and filters out `None` values.
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const filterMap: {
    <K, A, B>(self: HashMap<K, A>, f: (value: A) => Option<B>): HashMap<K, B>;
    <A, B>(f: (value: A) => Option<B>): <K>(self: HashMap<K, A>) => HashMap<K, B>;
};
/**
 * Maps over the entries of the `HashMap` using the specified partial function
 * and filters out `None` values.
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const filterMapWithIndex: {
    <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option<B>): HashMap<K, B>;
    <A, K, B>(f: (value: A, key: K) => Option<B>): (self: HashMap<K, A>) => HashMap<K, B>;
};
export {};
//# sourceMappingURL=HashMap.d.ts.map