import { $, TyK, PrimitiveType, $type, TyVar, HKT } from '@fp4ts/core';
import { Eq, Hashable } from '@fp4ts/cats-kernel';
import { SemigroupK } from '../../../semigroup-k';
import { MonoidK } from '../../../monoid-k';
import { Functor } from '../../../functor';
import { FunctorFilter } from '../../../functor-filter';
import { UnorderedFoldable } from '../../../unordered-foldable';
import { UnorderedTraversable } from '../../../unordered-traversable';
import { List } from '../list';
import { HashMap as HashMapBase } from './algebra';
export declare const HashMap: HashMapObj;
export type HashMap<K, V> = HashMapBase<K, V>;
export interface HashMapObj {
    <K extends PrimitiveType, V>(...pairs: [K, V][]): HashMap<K, V>;
    empty: HashMap<never, never>;
    of: <K2>(H: Hashable<K2>) => <K extends K2, V>(...pairs: [K, V][]) => HashMap<K2, V>;
    fromArray: <K2>(H: Hashable<K2>) => <K extends K2, V>(xs: [K, V][]) => HashMap<K2, V>;
    fromList: <K2>(H: Hashable<K2>) => <K extends K2, V>(xs: List<[K, V]>) => HashMap<K2, V>;
    Eq<K, V>(EK: Eq<K>, EV: Eq<V>): Eq<HashMap<K, V>>;
    SemigroupK<K>(E: Eq<K>): SemigroupK<$<HashMapF, [K]>>;
    MonoidK<K>(E: Eq<K>): MonoidK<$<HashMapF, [K]>>;
    Functor<K>(): Functor<$<HashMapF, [K]>>;
    FunctorFilter<K>(): FunctorFilter<$<HashMapF, [K]>>;
    UnorderedFoldable<K>(): UnorderedFoldable<$<HashMapF, [K]>>;
    UnorderedTraversable<K>(): UnorderedTraversable<$<HashMapF, [K]>>;
}
declare module './algebra' {
    interface HashMap<K, V> extends HKT<HashMapF, [K, V]> {
    }
}
/**
 * @category Type Constructor
 * @category Collection
 */
export interface HashMapF extends TyK<[unknown, unknown]> {
    [$type]: HashMap<TyVar<this, 0>, TyVar<this, 1>>;
}
//# sourceMappingURL=hash-map.d.ts.map