import { Kind } from '@fp4ts/core';
import { Monoid, Ord } from '@fp4ts/cats-kernel';
import { MonoidK } from '../../../monoid-k';
import { Show } from '../../../show';
import { Applicative } from '../../../applicative';
import { Option } from '../../option';
import { List } from '../list';
import { View } from '../view';
declare module './algebra' {
    interface Map<out K, out V> {
        readonly isEmpty: boolean;
        readonly nonEmpty: boolean;
        readonly head: V;
        readonly headOption: Option<V>;
        readonly tail: Map<K, V>;
        readonly init: Map<K, V>;
        readonly last: V;
        readonly lastOption: V;
        readonly view: View<[K, V]>;
        readonly toArray: [K, V][];
        readonly toList: List<[K, V]>;
        count(p: (v: V, k: K) => boolean): number;
        all(p: (v: V, k: K) => boolean): boolean;
        any(p: (v: V, k: K) => boolean): boolean;
        readonly min: Option<V>;
        readonly minWithKey: Option<[K, V]>;
        readonly max: Option<V>;
        readonly maxWithKey: Option<[K, V]>;
        readonly popMin: Option<[V, Map<K, V>]>;
        readonly popMinWithKey: Option<[[K, V], Map<K, V>]>;
        readonly popMax: Option<[V, Map<K, V>]>;
        readonly popMaxWithKey: Option<[[K, V], Map<K, V>]>;
        contains<K2>(this: Map<K2, V>, k: K2, O?: Ord<K2>): boolean;
        get<K2>(this: Map<K2, V>, k: K2, O?: Ord<K2>): V;
        '!!'<K2>(this: Map<K2, V>, k: K2, O?: Ord<K2>): V;
        lookup<K2>(this: Map<K2, V>, k: K2, O?: Ord<K2>): Option<V>;
        '!?'<K2>(this: Map<K2, V>, k: K2, O?: Ord<K2>): Option<V>;
        insert<K2, V2>(this: Map<K2, V2>, k: K2, v: V2, O?: Ord<K2>): Map<K2, V2>;
        insertWith<K2, V2>(this: Map<K2, V2>, k: K2, v: V2, u: (v1: V2, v2: V2, k: K2) => V2, O?: Ord<K2>): Map<K2, V2>;
        remove<K2>(this: Map<K2, V>, k: K2, O?: Ord<K2>): Map<K2, V>;
        update<K2, V2>(this: Map<K2, V2>, k: K2, u: (v: V2, k: K2) => V2, O?: Ord<K2>): Map<K2, V2>;
        '+++'<K2, V2>(this: Map<K2, V2>, that: Map<K2, V2>, O?: Ord<K2>): Map<K2, V2>;
        union<K2, V2>(this: Map<K2, V2>, that: Map<K2, V2>, O?: Ord<K2>): Map<K2, V2>;
        unionWith<K2, V2>(this: Map<K2, V2>, that: Map<K2, V2>, u: (v1: V2, v2: V2, k: K2) => V2, O?: Ord<K2>): Map<K2, V2>;
        intersect<K2, V2>(this: Map<K2, V>, m2: Map<K2, V2>, O?: Ord<K2>): Map<K2, V>;
        intersectWith<K2, V2, C>(this: Map<K2, V>, m2: Map<K2, V2>, f: (v1: V, v2: V2, k: K2) => C, O?: Ord<K2>): Map<K2, C>;
        '\\'<K2, V2>(this: Map<K2, V>, that: Map<K2, V2>, O?: Ord<K2>): Map<K2, V>;
        difference<K2, V2>(this: Map<K2, V>, that: Map<K2, V2>, O?: Ord<K2>): Map<K2, V>;
        '\\//'<K2, V2>(this: Map<K2, V2>, that: Map<K2, V2>, O?: Ord<K2>): Map<K2, V2>;
        symmetricDifference<K2, V2>(this: Map<K2, V2>, that: Map<K2, V2>, O?: Ord<K2>): Map<K2, V2>;
        filter<U extends V>(p: (v: V, k: K) => v is U): Map<K, U>;
        filter(p: (v: V, k: K) => boolean): Map<K, V>;
        map<B>(f: (v: V, k: K) => B): Map<K, B>;
        collect<B>(f: (v: V, k: K) => Option<B>): Map<K, B>;
        forEach(f: (v: V, k: K) => void): void;
        foldLeft<B>(z: B, f: (b: B, v: V, k: K) => B): B;
        foldLeft1<V2>(this: Map<K, V2>, f: (r: V2, v: V2) => V2): V2;
        foldRight<B>(z: B, f: (v: V, b: B, k: K) => B): B;
        foldRight1<V2>(this: Map<K, V2>, f: (v: V2, r: V2) => V2): V2;
        foldMap<M>(M: Monoid<M>): (f: (v: V, k: K) => M) => M;
        foldMapK<F>(F: MonoidK<F>): <B>(f: (v: V, k: K) => Kind<F, [B]>) => Kind<F, [B]>;
        traverse<G>(G: Applicative<G>): <B>(f: (v: V, k: K) => Kind<G, [B]>) => Kind<G, [Map<K, B>]>;
        show(this: Map<K, V>): string;
        show(this: Map<K, V>, SV: Show<V>): string;
        show(this: Map<K, V>, SK: Show<K>, SV: Show<V>): string;
    }
}
//# sourceMappingURL=syntax.d.ts.map