export declare abstract class Set<out A> {
    readonly __void: void;
    readonly _A: () => A;
    abstract readonly size: number;
}
export declare class Bin<A> extends Set<A> {
    readonly value: A;
    readonly lhs: Set<A>;
    readonly rhs: Set<A>;
    readonly tag = "bin";
    readonly size: number;
    constructor(value: A, lhs: Set<A>, rhs: Set<A>);
}
export declare const Empty: {
    readonly tag: "empty";
    readonly size: number;
    readonly __void: void;
    readonly _A: () => never;
    readonly isEmpty: boolean;
    readonly nonEmpty: boolean;
    readonly head: never;
    readonly headOption: import("../..").Option<never>;
    readonly tail: Set<never>;
    readonly last: never;
    readonly lastOption: import("../..").Option<never>;
    readonly init: Set<never>;
    readonly min: import("../..").Option<never>;
    readonly popMin: import("../..").Option<[never, Set<never>]>;
    readonly max: import("../..").Option<never>;
    readonly popMax: import("../..").Option<[never, Set<never>]>;
    readonly iterator: Iterator<never, any, undefined>;
    readonly reverseIterator: Iterator<never, any, undefined>;
    readonly toArray: never[];
    readonly toList: import("..").List<never>;
    readonly toVector: import("..").Vector<never>;
    readonly view: import("..").View<never>;
    contains<B>(this: Set<never>, x: B, O?: import("@fp4ts/cats-kernel").Ord<B> | undefined): boolean;
    all(p: (a: never) => boolean): boolean;
    any(p: (a: never) => boolean): boolean;
    count(p: (a: never) => boolean): number;
    elem(idx: number): never;
    '!!'(idx: number): never;
    elemOption(idx: number): import("../..").Option<never>;
    '!?'(idx: number): import("../..").Option<never>;
    take(n: number): Set<never>;
    takeRight(n: number): Set<never>;
    drop(n: number): Set<never>;
    dropRight(n: number): Set<never>;
    slice(from: number, until: number): Set<never>;
    insert<B_1>(this: Set<B_1>, x: B_1, O?: import("@fp4ts/cats-kernel").Ord<B_1> | undefined): Set<B_1>;
    remove<B_2>(this: Set<B_2>, x: B_2, O?: import("@fp4ts/cats-kernel").Ord<B_2> | undefined): Set<B_2>;
    union<B_3>(this: Set<B_3>, that: Set<B_3>, O?: import("@fp4ts/cats-kernel").Ord<B_3> | undefined): Set<B_3>;
    '+++'<B_4>(this: Set<B_4>, that: Set<B_4>, O?: import("@fp4ts/cats-kernel").Ord<B_4> | undefined): Set<B_4>;
    intersect<B_5>(this: Set<B_5>, that: Set<B_5>, O?: import("@fp4ts/cats-kernel").Ord<B_5> | undefined): Set<B_5>;
    difference<B_6>(this: Set<B_6>, that: Set<B_6>, O?: import("@fp4ts/cats-kernel").Ord<B_6> | undefined): Set<B_6>;
    '\\'<B_7>(this: Set<B_7>, that: Set<B_7>, O?: import("@fp4ts/cats-kernel").Ord<B_7> | undefined): Set<B_7>;
    symmetricDifference<B_8>(this: Set<B_8>, that: Set<B_8>, O?: import("@fp4ts/cats-kernel").Ord<B_8> | undefined): Set<B_8>;
    '\\//'<B_9>(this: Set<B_9>, that: Set<B_9>, O?: import("@fp4ts/cats-kernel").Ord<B_9> | undefined): Set<B_9>;
    split<B_10>(this: Set<B_10>, x: B_10, O?: import("@fp4ts/cats-kernel").Ord<B_10> | undefined): [Set<B_10>, Set<B_10>];
    filter(p: (a: never) => boolean): Set<never>;
    map<B_11>(f: (a: never) => B_11, O?: import("@fp4ts/cats-kernel").Ord<B_11> | undefined): Set<B_11>;
    forEach(f: (a: never) => void): void;
    partition(p: (a: never) => boolean): [Set<never>, Set<never>];
    foldLeft<B_12>(z: B_12, f: (b: B_12, x: never) => B_12): B_12;
    foldLeft1<B_13>(this: Set<B_13>, f: (b: B_13, x: B_13) => B_13): B_13;
    foldRight<B_14>(z: B_14, f: (x: never, b: B_14) => B_14): B_14;
    foldRight1<B_15>(this: Set<B_15>, f: (x: B_15, b: B_15) => B_15): B_15;
    foldMap<M>(M: import("@fp4ts/cats-kernel").Monoid<M>): (f: (a: never) => M) => M;
    foldMapLeft<M_1>(M: import("@fp4ts/cats-kernel").Monoid<M_1>): (f: (a: never) => M_1) => M_1;
    foldMapK<F>(F: import("../../..").MonoidK<F>): <B_16>(f: (a: never) => import("@fp4ts/core").Kind<F, [B_16]>) => import("@fp4ts/core").Kind<F, [B_16]>;
    equals<B_17>(this: Set<B_17>, E: import("@fp4ts/cats-kernel").Eq<B_17>): (that: Set<B_17>) => boolean;
    [Symbol.iterator](): Iterator<never, any, undefined>;
    readonly F: import("./set").SetF;
    readonly Vars: [never];
};
export type Empty = typeof Empty;
export type Node<A> = Bin<A> | Empty;
export declare const toNode: <A>(_: Set<A>) => Node<A>;
//# sourceMappingURL=algebra.d.ts.map