/**
 * ReadonlySet is a readonly product structure over objects
 * and it operates on object equality for deduplication.
 *
 * @module ReadonlySet
 * @since 2.0.0
 */
import "./_dnt.polyfills.js";
import type { $, Kind, Out } from "./kind.js";
import type { Applicable } from "./applicable.js";
import type { Combinable } from "./combinable.js";
import type { Comparable } from "./comparable.js";
import type { Either } from "./either.js";
import type { Filterable } from "./filterable.js";
import type { Flatmappable } from "./flatmappable.js";
import type { Foldable } from "./foldable.js";
import type { Initializable } from "./initializable.js";
import type { Mappable } from "./mappable.js";
import type { Option } from "./option.js";
import type { Pair } from "./pair.js";
import type { Predicate } from "./predicate.js";
import type { Refinement } from "./refinement.js";
import type { Showable } from "./showable.js";
import type { Traversable } from "./traversable.js";
import type { Wrappable } from "./wrappable.js";
/**
 * Extract the inner type of a ReadonlySet
 *
 * @since 2.0.0
 */
export type TypeOf<T> = T extends ReadonlySet<infer A> ? A : never;
/**
 * Specifies ReadonlySet as a Higher Kinded Type, with covariant
 * parameter A corresponding to the 0th index of any substitutions.
 *
 * @since 2.0.0
 */
export interface KindReadonlySet extends Kind {
    readonly kind: ReadonlySet<Out<this, 0>>;
}
/**
 * Constructs a new ReadonlySet over type A that conuains no values.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 *
 * const result = S.init<number>(); // ReadonlySet<number> with no members.
 * ```
 *
 * @since 2.0.0
 */
export declare function init<A = never>(): ReadonlySet<A>;
/**
 * Constructs a new ReadonlySet<A> from an arbitrary number
 * of values.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 *
 * const result = S.set(1, 2, 3); // ReadonlySet<number>
 * ```
 *
 * @since 2.0.0
 */
export declare function set<A>(...as: readonly [A, ...A[]]): ReadonlySet<A>;
/**
 * Copies an existing ReadonlySet into a new ReadonlySet, keeping
 * references to the original members.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 *
 * const original = S.set(1, 2, 3);
 * const copy = S.copy(original);
 *
 * const result1 = original === copy; // false
 *
 * const has = (value: number) => original.has(value) === copy.has(value);
 *
 * const result2 = has(1); // true;
 * const result3 = has(10); // true;
 * ```
 *
 * @since 2.0.0
 */
export declare function copy<A>(ua: ReadonlySet<A>): ReadonlySet<A>;
/**
 * Operates like Array.some, testing values in a ReadonlySet with a Predicate
 * until either the predicate returns true for a value or all of the
 * values have been tested. Shortcircuits on the first value that
 * returns true. This is the dual of every.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 *
 * const some = S.some((n: number) => n > 0);
 *
 * const result1 = some(S.set(1, 2, 3)); // true
 * const result2 = some(S.set(0)); // false
 * const result3 = some(S.init()); // false
 * const result4 = some(S.set(-1, -2, -3, 1)); // true
 * ```
 *
 * @since 2.0.0
 */
export declare function some<A>(predicate: Predicate<A>): (ua: ReadonlySet<A>) => boolean;
/**
 * Operates like Array.every, testing values in a ReadonlySet with a Predicate
 * until either the predicate returns false for a value or all of the
 * values have been tested as true. Shortcircuits on the first value that
 * returns false. This is the dual of some.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 *
 * const some = S.some((n: number) => n > 0);
 *
 * const result1 = some(S.set(1, 2, 3)); // true
 * const result2 = some(S.set(0)); // false
 * const result3 = some(S.init()); // false
 * const result4 = some(S.set(-1, -2, -3, 1)); // true
 * ```
 *
 * @since 2.0.0
 */
export declare function every<A>(predicate: Predicate<A>): (ua: ReadonlySet<A>) => boolean;
/**
 * Given an insuance of Comparable<A> create a function
 * that takes a value A and returns a predicate over
 * ReadonlySet<A> the returns true if there are any
 * members of the set that are equal to the value.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as N from "./number.ts";
 * import { pipe } from "./fn.ts";
 *
 * const elem = S.elem(N.ComparableNumber);
 *
 * const set = S.set(1, 2, 3);
 *
 * const result1 = pipe(set, elem(1)); // true
 * const result2 = pipe(set, elem(10)); // false
 * ```
 *
 * @since 2.0.0
 */
export declare function elem<A>({ compare }: Comparable<A>): (value: A) => (ua: ReadonlySet<A>) => boolean;
/**
 * Given an instance of Comparable<A> create a function
 * that uakes a ReadonlySet<A> and returns a predicate over
 * a value A the returns true if the value is a member
 * of the set. This is like elem but with the set and value
 * parameters swapped.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as N from "./number.ts";
 *
 * const elemOf = S.elemOf(N.ComparableNumber);
 *
 * const set = S.set(1, 2, 3);
 * const inSet = elemOf(set);
 *
 * const result1 = inSet(1); // true
 * const result2 = inSet(10); // false
 * ```
 *
 * @since 2.0.0
 */
export declare function elemOf<A>(S: Comparable<A>): (ua: ReadonlySet<A>) => (a: A) => boolean;
/**
 * Given an instance of Comparable<A> return a function
 * `second => first => boolean` that returns true when
 * every member of first is in second.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as N from "./number.ts";
 * import { pipe } from "./fn.ts";
 *
 * const subset = S.isSubset(N.ComparableNumber);
 *
 * const big = S.set(1, 2, 3, 4, 5);
 * const small = S.set(2, 4);
 *
 * const result1 = pipe(big, subset(small)); // false
 * const result2 = pipe(small, subset(big)); // true;
 * ```
 *
 * @since 2.0.0
 */
export declare function isSubset<A>(S: Comparable<A>): (second: ReadonlySet<A>) => (first: ReadonlySet<A>) => boolean;
/**
 * Given an instance of Comparable<A> return a function that takes
 * two ReadonlySet<A>s and merges them into a new ReadonlySet<A>
 * that contains all the elements from both sets.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as N from "./number.ts";
 * import { pipe } from "./fn.ts";
 *
 * const union = S.union(N.ComparableNumber);
 * const s1 = S.set(1, 2, 3, 4);
 * const s2 = S.set(3, 4, 5, 6);
 *
 * const result = pipe(s1, union(s2));
 * // Set(1, 2, 3, 4, 5, 6)
 * ```
 *
 * @since 2.0.0
 */
export declare function union<A>(S: Comparable<A>): (second: ReadonlySet<A>) => (first: ReadonlySet<A>) => ReadonlySet<A>;
/**
 * Given an instance of Comparable<A> return a function that takes
 * two ReadonlySet<A>s and returns a new set with only
 * the elements that exist in both sets.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as N from "./number.ts";
 * import { pipe } from "./fn.ts";
 *
 * const intersect = S.intersection(N.ComparableNumber);
 * const s1 = S.set(1, 2, 3, 4);
 * const s2 = S.set(3, 4, 5, 6);
 *
 * const result = pipe(s1, intersect(s2));
 * // Set(3, 4)
 * ```
 *
 * @since 2.0.0
 */
export declare function intersection<A>(S: Comparable<A>): (ua: ReadonlySet<A>) => (tb: ReadonlySet<A>) => ReadonlySet<A>;
/**
 * Given an instance of Comparable<A> create a function that will
 * take a ReadonlySet<A> and return a new ReadonlySet<A> where
 * any members that are equal are deduplicated.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as N from "./number.ts";
 * import * as E from "./comparable.ts";
 *
 * const eq = E.struct({ num: N.ComparableNumber });
 * const compact = S.compact(eq);
 *
 * const set = S.set({ num: 1 }, { num: 1 }, { num: 2 });
 * // Set({ num: 1 }, { num: 1 }, { num: 2 })
 *
 * const result = compact(set); // Set({ num: 1 }, { num: 2 })
 * ```
 *
 * @since 2.0.0
 */
export declare function compact<A>(S: Comparable<A>): (ua: ReadonlySet<A>) => ReadonlySet<A>;
/**
 * Given a value A create a new ReadonlySet<A> that
 * contains that value.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 *
 * const result = S.wrap(1); // Set(1);
 * ```
 *
 * @since 2.0.0
 */
export declare function wrap<A>(a: A): ReadonlySet<A>;
/**
 * Given a function A -> I and a ReadonlySet<A> return
 * a new ReadonlySet<I> where the values were created
 * by passing each A through the A -> I function.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import { pipe } from "./fn.ts";
 *
 * const set = S.set("hello", "world", "goodbye");
 *
 * const result = pipe(
 *   set,
 *   S.map(s => s.length),
 * ); // Set(5, 7);
 * ```
 *
 * @since 2.0.0
 */
export declare function map<A, I>(fai: (a: A) => I): (ua: ReadonlySet<A>) => ReadonlySet<I>;
/**
 * Given a ReadonlySet of functions A -> I and
 * a ReadonlySet<A> return a ReadonlySet<I> by applying
 * every function to every value A.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import { pipe } from "./fn.ts";
 *
 * type Person = { name: string, age: number };
 *
 * const person = (name: string) => (age: number): Person => ({ name, age });
 *
 * const result = pipe(
 *   S.wrap(person),
 *   S.apply(S.wrap("Brandon")),
 *   S.apply(S.wrap(37)),
 * ); // ReadonlySet<Person>
 * ```
 *
 * @since 2.0.0
 */
export declare function apply<A>(ua: ReadonlySet<A>): <I>(ufai: ReadonlySet<(a: A) => I>) => ReadonlySet<I>;
/**
 * Given a function A -> ReadonlySet<I> and a ReadonlySet<A>
 * return a ReadonlySet<I> created by applying the function
 * to every value A and joining all the resulting ReadonlySet<I>s.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import { pipe } from "./fn.ts";
 *
 * const set = S.set(1, 2, 3, 4, 5);
 *
 * const result = pipe(
 *   set,
 *   S.flatmap(n => S.set(n, n + 1, n + 2)),
 * ); // Set(1, 2, 3, 4, 5, 6, 7);
 * ```
 *
 * @since 2.0.0
 */
export declare function flatmap<A, I>(fati: (a: A) => ReadonlySet<I>): (ua: ReadonlySet<A>) => ReadonlySet<I>;
/**
 * Given a ReadonlySet of ReadonlySet<A>, flatten all of the inner
 * sets and return a ReadonlySet<A>.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 *
 * const setOfSets = S.set(S.set(1, 2), S.set(3, 4), S.set(1, 4));
 *
 * const result = S.join(setOfSets); // Set(1, 2, 3, 4)
 * ```
 *
 * @since 2.0.0
 */
export declare function join<A>(uua: ReadonlySet<ReadonlySet<A>>): ReadonlySet<A>;
/**
 * Given a Refinement or Predicate over A and a ReadonlySet<A> return
 * a new ReadonlySet with only values for which the predicate or
 * refinement return true.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import { pipe } from "./fn.ts";
 *
 * const set = S.set(1, 2, 3, 4, 5);
 *
 * const result1 = pipe(set, S.filter(n => n > 2)); // Set(3, 4, 5)
 * const result2 = pipe(set, S.filter(n => n === 0)); // Set()
 * ```
 *
 * @since 2.0.0
 */
export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (ua: ReadonlySet<A>) => ReadonlySet<B>;
export declare function filter<A>(predicate: Predicate<A>): (ua: ReadonlySet<A>) => ReadonlySet<A>;
/**
 * Given a function A -> Option<I> and a ReadonlySet<A> return
 * a ReadonlySet<I> by applying the function to all values A. Any
 * Nones will not enter the resultant set while Some<I> values will.
 * This is effectively filtering and mapping simultaneously.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as O from "./option.ts";
 * import { pipe } from "./fn.ts";
 *
 * const set = S.set("one", "two", "three", "four", "five");
 *
 * const result = pipe(
 *   set,
 *   S.filterMap(s => s.includes('o') ? O.some(s.length) : O.none),
 * ); // Set(3, 4)
 * ```
 *
 * @since 2.0.0
 */
export declare function filterMap<A, I>(fai: (a: A) => Option<I>): (ua: ReadonlySet<A>) => ReadonlySet<I>;
/**
 * Given a Predicate or Refinement over A and a ReadonlySet<A>
 * return a Pair with a first value being a ReadonlySet of values
 * that return true when applied to the refinement or predicate
 * and a second value being a ReadonlySet of values that return
 * false when applied to the predicate.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import { pipe } from "./fn.ts";
 *
 * const set = S.set(1, 2, 3, 4);
 *
 * const result = pipe(
 *   set,
 *   S.partition(n => n > 2),
 * ); // [Set(3, 4), Set(1, 2)]
 * ```
 *
 * @since 2.0.0
 */
export declare function partition<A, B extends A>(refinement: Refinement<A, B>): (ua: ReadonlySet<A>) => Pair<ReadonlySet<B>, ReadonlySet<A>>;
export declare function partition<A>(predicate: Predicate<A>): (ua: ReadonlySet<A>) => Pair<ReadonlySet<A>, ReadonlySet<A>>;
/**
 * Given a function A -> Either<J, I> and a ReadonlySet<A> return
 * a Pair(ReadonlySet<I>, ReadonlySet<J>) by applying every value A
 * in the set to the partitioning function.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as E from "./either.ts";
 * import { pipe } from "./fn.ts";
 *
 * const set = S.set("one", "two", "three", "four");
 *
 * const result = pipe(
 *   set,
 *   S.partitionMap(s => s.includes('o') ? E.right(s) : E.left(s.length)),
 * ); // [Set("one", "two", "four"), Set(5)]
 * ```
 *
 * @since 2.0.0
 */
export declare function partitionMap<A, I, J>(fai: (a: A) => Either<J, I>): (ua: ReadonlySet<A>) => Pair<ReadonlySet<I>, ReadonlySet<J>>;
/**
 * Reduce a ReadonlySet<A> to a value O by iterating over
 * the values of the set and collecting them with the reducing function.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import { pipe } from "./fn.ts";
 *
 * const set = S.set(1, 2, 3, 4);
 *
 * const result = pipe(
 *   set,
 *   S.fold((previous, current) => previous + current, 0),
 * ); // 10
 * ```
 *
 * @since 2.0.0
 */
export declare function fold<A, O>(foao: (o: O, a: A) => O, o: O): (ua: ReadonlySet<A>) => O;
/**
 * Traverse a ReadonlySet<A> value by value, applying a function
 * A -> V<I>, then collecting all of the I values into ReadonlySet<I>
 * and returning V<ReadonlySet<I>>. In concrete terms this can take
 * ReadonlySet<Option<A>> and turn it into Option<ReadonlySet<I>> and
 * other ADT inversions.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as O from "./option.ts";
 * import { pipe } from "./fn.ts";
 *
 * const traverseOption = S.traverse(O.ApplicableOption);
 * const invert = traverseOption((o: O.Option<number>) => o);
 *
 * const result1 = pipe(
 *   S.set(O.some(1), O.some(2), O.some(3)),
 *   invert,
 * ); // Some(Set(1, 2, 3))
 * const result2 = pipe(
 *   S.set(O.some(1), O.some(2), O.none),
 *   invert,
 * ); // None
 * ```
 *
 * @since 2.0.0
 */
export declare function traverse<V extends Kind>(A: Applicable<V>): <A, I, J, K, L, M>(favi: (a: A) => $<V, [I, J, K], [L], [M]>) => (ua: ReadonlySet<A>) => $<V, [ReadonlySet<I>, J, K], [L], [M]>;
/**
 * Given an instance of Showable<A> return an instance of Showable<ReadonlySet<A>>.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as N from "./number.ts";
 *
 * const { show } = S.getShowableSet(N.ShowableNumber);
 *
 * const result1 = show(S.init()); // "Set([])"
 * const result2 = show(S.set(1, 2, 3)); // "Set([1, 2, 3])"
 * ```
 *
 * @since 2.0.0
 */
export declare function getShowableSet<A>(S: Showable<A>): Showable<ReadonlySet<A>>;
/**
 * Given an instance of Comparable<A> return Comparable<ReadonlySet<A>>.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as N from "./number.ts";
 * import { pipe } from "./fn.ts";
 *
 * const { compare } = S.getComparableSet(N.ComparableNumber);
 *
 * const result1 = compare(
 *   S.set(1, 2, 3))(
 *   S.set(3, 2, 1)
 * ); // true
 * const result2 = compare(
 *   S.set(1, 2, 3))(
 *   S.set(1, 2, 3, 4)
 * ); // false
 * ```
 *
 * @since 2.0.0
 */
export declare function getComparableSet<A>(S: Comparable<A>): Comparable<ReadonlySet<A>>;
/**
 * Given an instance of Comparable<A> create a Combinable<ReadonlySet<A>> where
 * combine creates a union of two ReadonlySets.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as N from "./number.ts";
 * import * as M from "./combinable.ts";
 * import { pipe } from "./fn.ts";
 *
 * const monoid = S.getCombinableSet(N.ComparableNumber);
 * const combineAll = M.getCombineAll(monoid);
 *
 * const result1 = combineAll(
 *   S.set(1, 2, 3),
 *   S.set(4, 5, 6),
 *   S.set(1, 3, 5, 7)
 * ); // Set(1, 2, 3, 4, 5, 6, 7)
 * const result3 = combineAll(S.init()); // Set()
 * ```
 *
 * @since 2.0.0
 */
export declare function getCombinableSet<A>(S: Comparable<A>): Combinable<ReadonlySet<A>>;
/**
 * Given an instance of Comparable<A> create a Combinable<ReadonlySet<A>> where
 * combine creates a union of two ReadonlySets.
 *
 * @example
 * ```ts
 * import * as S from "./set.ts";
 * import * as N from "./number.ts";
 * import * as M from "./combinable.ts";
 * import { pipe } from "./fn.ts";
 *
 * const monoid = S.getInitializableSet(N.ComparableNumber);
 * const combineAll = M.getCombineAll(monoid);
 *
 * const result1 = combineAll(
 *   S.set(1, 2, 3),
 *   S.set(4, 5, 6),
 *   S.set(1, 3, 5, 7)
 * ); // Set(1, 2, 3, 4, 5, 6, 7)
 * const result3 = combineAll(S.init()); // Set()
 * ```
 *
 * @since 2.0.0
 */
export declare function getInitializableSet<A>(C: Comparable<A>): Initializable<ReadonlySet<A>>;
/**
 * The canonical implementation of Applicable for ReadonlySet. It contains
 * the methods wrap, ap, and map.
 *
 * @since 2.0.0
 */
export declare const ApplicableSet: Applicable<KindReadonlySet>;
/**
 * The canonical implementation of Filterable for ReadonlySet. It contains
 * the methods filter, filterMap, partition, and partitionMap.
 *
 * @since 2.0.0
 */
export declare const FilterableSet: Filterable<KindReadonlySet>;
/**
 * The canonical implementation of Flatmappable for ReadonlySet. It contains
 * the methods wrap, ap, map, join, and flatmap.
 *
 * @since 2.0.0
 */
export declare const FlatmappableSet: Flatmappable<KindReadonlySet>;
/**
 * The canonical implementation of Foldable for ReadonlySet. It contains
 * the method fold.
 *
 * @since 2.0.0
 */
export declare const FoldableSet: Foldable<KindReadonlySet>;
/**
 * The canonical implementation of Mappable for ReadonlySet. It contains
 * the method map.
 *
 * @since 2.0.0
 */
export declare const MappableSet: Mappable<KindReadonlySet>;
/**
 * The canonical implementation of Traversable for ReadonlySet. It contains
 * the methods map, fold, and traverse.
 *
 * @since 2.0.0
 */
export declare const TraversableSet: Traversable<KindReadonlySet>;
/**
 * @since 2.0.0
 */
export declare const WrappableSet: Wrappable<KindReadonlySet>;
/**
 * @since 2.0.0
 */
export declare const tap: <A>(fn: (value: A) => void) => <B = never, C = never, D = unknown, E = unknown>(ua: ReadonlySet<A>) => ReadonlySet<A>;
/**
 * @since 2.0.0
 */
export declare const bind: <N extends string, A, I, J = never, K = never, L = unknown, M = unknown>(name: Exclude<N, keyof A>, faui: (a: A) => ReadonlySet<I>) => <B = never, C = never, D extends L = L>(ua: ReadonlySet<A>) => ReadonlySet<{ readonly [K_1 in N | keyof A]: K_1 extends keyof A ? A[K_1] : I; }>;
/**
 * @since 2.0.0
 */
export declare const bindTo: <N extends string>(name: N) => <A, B = never, C = never, D = unknown, E = unknown>(ua: ReadonlySet<A>) => ReadonlySet<{ readonly [K in N]: A; }>;