import { Kind } from '@fp4ts/core';
import { Eq, Monoid, Ord } from '@fp4ts/cats-kernel';
import { MonoidK } from '../../../monoid-k';
import { Option } from '../../option';
import { List } from '../list';
import { Vector } from '../vector';
import { View } from '../view';
declare module './algebra' {
    interface Set<out A> {
        readonly isEmpty: boolean;
        readonly nonEmpty: boolean;
        readonly head: A;
        readonly headOption: Option<A>;
        readonly tail: Set<A>;
        readonly last: A;
        readonly lastOption: Option<A>;
        readonly init: Set<A>;
        readonly min: Option<A>;
        readonly popMin: Option<[A, Set<A>]>;
        readonly max: Option<A>;
        readonly popMax: Option<[A, Set<A>]>;
        readonly iterator: Iterator<A>;
        [Symbol.iterator](): Iterator<A>;
        readonly reverseIterator: Iterator<A>;
        readonly toArray: A[];
        readonly toList: List<A>;
        readonly toVector: Vector<A>;
        readonly view: View<A>;
        contains<B>(this: Set<A>, x: B, O?: Ord<B>): boolean;
        all(p: (a: A) => boolean): boolean;
        any(p: (a: A) => boolean): boolean;
        count(p: (a: A) => boolean): number;
        elem(idx: number): A;
        '!!'(idx: number): A;
        elemOption(idx: number): Option<A>;
        '!?'(idx: number): Option<A>;
        take(n: number): Set<A>;
        takeRight(n: number): Set<A>;
        drop(n: number): Set<A>;
        dropRight(n: number): Set<A>;
        slice(from: number, until: number): Set<A>;
        insert<B>(this: Set<B>, x: B, O?: Ord<B>): Set<B>;
        remove<B>(this: Set<B>, x: B, O?: Ord<B>): Set<B>;
        union<B>(this: Set<B>, that: Set<B>, O?: Ord<B>): Set<B>;
        '+++'<B>(this: Set<B>, that: Set<B>, O?: Ord<B>): Set<B>;
        intersect<B>(this: Set<B>, that: Set<B>, O?: Ord<B>): Set<B>;
        difference<B>(this: Set<B>, that: Set<B>, O?: Ord<B>): Set<B>;
        '\\'<B>(this: Set<B>, that: Set<B>, O?: Ord<B>): Set<B>;
        symmetricDifference<B>(this: Set<B>, that: Set<B>, O?: Ord<B>): Set<B>;
        '\\//'<B>(this: Set<B>, that: Set<B>, O?: Ord<B>): Set<B>;
        split<B>(this: Set<B>, x: B, O?: Ord<B>): [Set<B>, Set<B>];
        filter(p: (a: A) => boolean): Set<A>;
        map<B>(f: (a: A) => B, O?: Ord<B>): Set<B>;
        forEach(f: (a: A) => void): void;
        partition(p: (a: A) => boolean): [Set<A>, Set<A>];
        foldLeft<B>(z: B, f: (b: B, x: A) => B): B;
        foldLeft1<B>(this: Set<B>, f: (b: B, x: B) => B): B;
        foldRight<B>(z: B, f: (x: A, b: B) => B): B;
        foldRight1<B>(this: Set<B>, f: (x: B, b: B) => B): B;
        foldMap<M>(M: Monoid<M>): (f: (a: A) => M) => M;
        foldMapLeft<M>(M: Monoid<M>): (f: (a: A) => M) => M;
        foldMapK<F>(F: MonoidK<F>): <B>(f: (a: A) => Kind<F, [B]>) => Kind<F, [B]>;
        equals<B>(this: Set<B>, E: Eq<B>): (that: Set<B>) => boolean;
    }
}
//# sourceMappingURL=syntax.d.ts.map