import { $, TyK, PrimitiveType, $type, TyVar, HKT } from '@fp4ts/core';
import { Eq, Ord } from '@fp4ts/cats-kernel';
import { SemigroupK } from '../../../semigroup-k';
import { MonoidK } from '../../../monoid-k';
import { FunctorFilter } from '../../../functor-filter';
import { FoldableWithIndex } from '../../../foldable-with-index';
import { FunctorWithIndex } from '../../../functor-with-index';
import { TraversableWithIndex } from '../../../traversable-with-index';
import { List } from '../list';
import { Map as MapBase } from './algebra';
export type Map<K, V> = MapBase<K, V>;
export declare const Map: OrderedMapObj;
export interface OrderedMapObj {
    <K extends PrimitiveType, V>(...pairs: [K, V][]): Map<K, V>;
    empty: Map<never, never>;
    singleton<K, V>(k: K, v: V): Map<K, V>;
    fromList<K>(O: Ord<K>): <V>(xs: List<[K, V]>) => Map<K, V>;
    fromArray<K>(O: Ord<K>): <V>(xs: [K, V][]) => Map<K, V>;
    fromSortedArray<K, V>(xs: [K, V][]): Map<K, V>;
    Eq<K, V>(EK: Eq<K>, EV: Eq<V>): Eq<Map<K, V>>;
    SemigroupK: <K>(O: Ord<K>) => SemigroupK<$<MapF, [K]>>;
    MonoidK: <K>(O: Ord<K>) => MonoidK<$<MapF, [K]>>;
    FunctorWithIndex: <K>() => FunctorWithIndex<$<MapF, [K]>, K>;
    FunctorFilter: <K>() => FunctorFilter<$<MapF, [K]>>;
    FoldableWithIndex: <K>() => FoldableWithIndex<$<MapF, [K]>, K>;
    TraversableWithIndex: <K>() => TraversableWithIndex<$<MapF, [K]>, K>;
}
declare module './algebra' {
    interface Map<K, V> extends HKT<MapF, [K, V]> {
    }
}
/**
 * @category Type Constructor
 * @category Collection
 */
export interface MapF extends TyK<[unknown, unknown]> {
    [$type]: Map<TyVar<this, 0>, TyVar<this, 1>>;
}
//# sourceMappingURL=map.d.ts.map