/**
 * The `TxHashSet` module provides a transactional hash set for storing unique
 * values inside Effect transactions. A `TxHashSet<A>` wraps a `HashSet<A>` in a
 * transactional reference, so reads and writes can be composed with other
 * transactional operations and committed atomically.
 *
 * **Common tasks**
 *
 * - Create transactional sets with {@link empty}, {@link make}, or {@link fromIterable}
 * - Mutate an existing set with {@link add}, {@link remove}, and {@link clear}
 * - Query membership and size with {@link has}, {@link size}, and {@link isEmpty}
 * - Derive new sets with {@link map}, {@link filter}, {@link union}, {@link intersection}, and {@link difference}
 * - Fold or collect values with {@link reduce} and {@link toHashSet}
 *
 * **Gotchas**
 *
 * - Mutation operations update the same transactional set; transform operations
 *   return a new `TxHashSet`
 * - Operations are `Effect` values and must be yielded, piped, or run to take effect
 * - Use `Effect.tx` when several operations must observe and commit one atomic transaction
 *
 * @since 2.0.0
 */
import * as Effect from "./Effect.ts";
import * as HashSet from "./HashSet.ts";
import type { Inspectable } from "./Inspectable.ts";
import type { Pipeable } from "./Pipeable.ts";
import { type Predicate, type Refinement } from "./Predicate.ts";
import * as TxRef from "./TxRef.ts";
import type { NoInfer } from "./Types.ts";
declare const TypeId = "~effect/transactions/TxHashSet";
/**
 * A TxHashSet is a transactional hash set data structure that provides atomic operations on unique values within Effect transactions. It uses an immutable HashSet internally with TxRef for transactional semantics, ensuring all operations are performed atomically.
 *
 * **Details**
 *
 * Mutation operations such as `add`, `remove`, and `clear` update the original TxHashSet and return `Effect<void>` or `Effect<boolean>`. Transform operations such as `union`, `intersection`, `difference`, `map`, and `filter` create new TxHashSet instances and leave the original TxHashSet unchanged.
 *
 * **Example** (Using transactional hash sets)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   // Create a transactional hash set
 *   const txSet = yield* TxHashSet.make("apple", "banana", "cherry")
 *
 *   // Single operations are automatically transactional
 *   yield* TxHashSet.add(txSet, "grape")
 *   const hasApple = yield* TxHashSet.has(txSet, "apple")
 *   console.log(hasApple) // true
 *
 *   // Multi-step atomic operations
 *   yield* Effect.tx(
 *     Effect.gen(function*() {
 *       const hasCherry = yield* TxHashSet.has(txSet, "cherry")
 *       if (hasCherry) {
 *         yield* TxHashSet.remove(txSet, "cherry")
 *         yield* TxHashSet.add(txSet, "orange")
 *       }
 *     })
 *   )
 *
 *   const size = yield* TxHashSet.size(txSet)
 *   console.log(size) // 4
 * })
 * ```
 *
 * @category models
 * @since 4.0.0
 */
export interface TxHashSet<in out V> extends Inspectable, Pipeable {
    readonly [TypeId]: typeof TypeId;
    readonly ref: TxRef.TxRef<HashSet.HashSet<V>>;
}
/**
 * The TxHashSet namespace contains type-level utilities and helper types
 * for working with TxHashSet instances.
 *
 * **Example** (Extracting value types inside transactions)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   // Create a transactional color set
 *   const colors = yield* TxHashSet.make("red", "green", "blue")
 *
 *   // Extract the value type for reuse
 *   type Color = TxHashSet.TxHashSet.Value<typeof colors> // string
 *
 *   // Use extracted type in functions
 *   const addColor = (color: Color) => TxHashSet.add(colors, color)
 *
 *   yield* addColor("yellow")
 * })
 * ```
 *
 * @since 4.0.0
 */
export declare namespace TxHashSet {
    /**
     * Extracts the value type from a `TxHashSet` type.
     *
     * **Example** (Extracting a TxHashSet value type)
     *
     * ```ts
     * import type { TxHashSet } from "effect"
     *
     * type FruitSet = TxHashSet.TxHashSet<"apple" | "banana" | "cherry">
     *
     * // Extract the value type
     * type Fruit = TxHashSet.TxHashSet.Value<FruitSet> // "apple" | "banana" | "cherry"
     *
     * const processFruit = (fruit: Fruit) => {
     *   return `Processing ${fruit}`
     * }
     *
     * console.log(processFruit("apple")) // Processing apple
     * ```
     *
     * @category utility types
     * @since 4.0.0
     */
    type Value<T> = T extends TxHashSet<infer V> ? V : never;
}
/**
 * Creates an empty TxHashSet.
 *
 * **Example** (Creating an empty transactional hash set)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const txSet = yield* TxHashSet.empty<string>()
 *
 *   console.log(yield* TxHashSet.size(txSet)) // 0
 *   console.log(yield* TxHashSet.isEmpty(txSet)) // true
 *
 *   // Add some values
 *   yield* TxHashSet.add(txSet, "hello")
 *   yield* TxHashSet.add(txSet, "world")
 *   console.log(yield* TxHashSet.size(txSet)) // 2
 * })
 * ```
 *
 * @category constructors
 * @since 2.0.0
 */
export declare const empty: <V = never>() => Effect.Effect<TxHashSet<V>>;
/**
 * Creates a TxHashSet from a variable number of values.
 *
 * **Example** (Creating transactional hash sets from values)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const fruits = yield* TxHashSet.make("apple", "banana", "cherry")
 *   console.log(yield* TxHashSet.size(fruits)) // 3
 *
 *   const numbers = yield* TxHashSet.make(1, 2, 3, 2, 1) // Duplicates ignored
 *   console.log(yield* TxHashSet.size(numbers)) // 3
 *
 *   const mixed = yield* TxHashSet.make("hello", 42, true)
 *   console.log(yield* TxHashSet.size(mixed)) // 3
 * })
 * ```
 *
 * @category constructors
 * @since 2.0.0
 */
export declare const make: <Values extends ReadonlyArray<any>>(...values: Values) => Effect.Effect<TxHashSet<Values[number]>>;
/**
 * Creates a TxHashSet from an iterable collection of values.
 *
 * **Example** (Creating a transactional hash set from an iterable)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const fromArray = yield* TxHashSet.fromIterable(["a", "b", "c", "b", "a"])
 *   console.log(yield* TxHashSet.size(fromArray)) // 3
 *
 *   const fromSet = yield* TxHashSet.fromIterable(new Set([1, 2, 3]))
 *   console.log(yield* TxHashSet.size(fromSet)) // 3
 *
 *   const fromString = yield* TxHashSet.fromIterable("hello")
 *   const values = yield* TxHashSet.toHashSet(fromString)
 *   console.log(Array.from(values).sort()) // ["e", "h", "l", "o"]
 * })
 * ```
 *
 * @category constructors
 * @since 2.0.0
 */
export declare const fromIterable: <V>(values: Iterable<V>) => Effect.Effect<TxHashSet<V>>;
/**
 * Creates a TxHashSet from an existing HashSet.
 *
 * **Example** (Creating a transactional hash set from a HashSet)
 *
 * ```ts
 * import { Effect, HashSet, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const hashSet = HashSet.make("x", "y", "z")
 *   const txSet = yield* TxHashSet.fromHashSet(hashSet)
 *
 *   console.log(yield* TxHashSet.size(txSet)) // 3
 *   console.log(yield* TxHashSet.has(txSet, "y")) // true
 *
 *   // Original hashSet is unchanged when txSet is modified
 *   yield* TxHashSet.add(txSet, "w")
 *   console.log(HashSet.size(hashSet)) // 3 (original unchanged)
 *   console.log(yield* TxHashSet.size(txSet)) // 4
 * })
 * ```
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const fromHashSet: <V>(hashSet: HashSet.HashSet<V>) => Effect.Effect<TxHashSet<V>>;
/**
 * Checks whether a value is a TxHashSet.
 *
 * **Example** (Checking for a TxHashSet)
 *
 * ```ts
 * import { Effect, HashSet, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const txSet = yield* TxHashSet.make(1, 2, 3)
 *   const hashSet = HashSet.make(1, 2, 3)
 *   const array = [1, 2, 3]
 *
 *   console.log(TxHashSet.isTxHashSet(txSet)) // true
 *   console.log(TxHashSet.isTxHashSet(hashSet)) // false
 *   console.log(TxHashSet.isTxHashSet(array)) // false
 *   console.log(TxHashSet.isTxHashSet(null)) // false
 * })
 * ```
 *
 * @category guards
 * @since 4.0.0
 */
export declare const isTxHashSet: (u: unknown) => u is TxHashSet<unknown>;
/**
 * Adds a value to the TxHashSet. If the value already exists, the operation has no effect.
 *
 * **Details**
 *
 * This function mutates the original TxHashSet by adding the specified value. It does not return a new TxHashSet reference.
 *
 * **Example** (Adding values)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const txSet = yield* TxHashSet.make("a", "b")
 *
 *   yield* TxHashSet.add(txSet, "c")
 *   console.log(yield* TxHashSet.size(txSet)) // 3
 *   console.log(yield* TxHashSet.has(txSet, "c")) // true
 *
 *   // Adding existing value has no effect
 *   yield* TxHashSet.add(txSet, "a")
 *   console.log(yield* TxHashSet.size(txSet)) // 3 (unchanged)
 * })
 * ```
 *
 * @category mutations
 * @since 2.0.0
 */
export declare const add: {
    /**
     * Adds a value to the TxHashSet. If the value already exists, the operation has no effect.
     *
     * **Details**
     *
     * This function mutates the original TxHashSet by adding the specified value. It does not return a new TxHashSet reference.
     *
     * **Example** (Adding values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const txSet = yield* TxHashSet.make("a", "b")
     *
     *   yield* TxHashSet.add(txSet, "c")
     *   console.log(yield* TxHashSet.size(txSet)) // 3
     *   console.log(yield* TxHashSet.has(txSet, "c")) // true
     *
     *   // Adding existing value has no effect
     *   yield* TxHashSet.add(txSet, "a")
     *   console.log(yield* TxHashSet.size(txSet)) // 3 (unchanged)
     * })
     * ```
     *
     * @category mutations
     * @since 2.0.0
     */
    <V>(value: V): (self: TxHashSet<V>) => Effect.Effect<void>;
    /**
     * Adds a value to the TxHashSet. If the value already exists, the operation has no effect.
     *
     * **Details**
     *
     * This function mutates the original TxHashSet by adding the specified value. It does not return a new TxHashSet reference.
     *
     * **Example** (Adding values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const txSet = yield* TxHashSet.make("a", "b")
     *
     *   yield* TxHashSet.add(txSet, "c")
     *   console.log(yield* TxHashSet.size(txSet)) // 3
     *   console.log(yield* TxHashSet.has(txSet, "c")) // true
     *
     *   // Adding existing value has no effect
     *   yield* TxHashSet.add(txSet, "a")
     *   console.log(yield* TxHashSet.size(txSet)) // 3 (unchanged)
     * })
     * ```
     *
     * @category mutations
     * @since 2.0.0
     */
    <V>(self: TxHashSet<V>, value: V): Effect.Effect<void>;
};
/**
 * Removes a value from the TxHashSet.
 *
 * **Details**
 *
 * This function mutates the original TxHashSet by removing the specified value. It does not return a new TxHashSet reference.
 *
 * **Example** (Removing values)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const txSet = yield* TxHashSet.make("a", "b", "c")
 *
 *   const removed = yield* TxHashSet.remove(txSet, "b")
 *   console.log(removed) // true (value existed and was removed)
 *   console.log(yield* TxHashSet.size(txSet)) // 2
 *   console.log(yield* TxHashSet.has(txSet, "b")) // false
 *
 *   // Removing non-existent value returns false
 *   const notRemoved = yield* TxHashSet.remove(txSet, "d")
 *   console.log(notRemoved) // false
 * })
 * ```
 *
 * @category mutations
 * @since 2.0.0
 */
export declare const remove: {
    /**
     * Removes a value from the TxHashSet.
     *
     * **Details**
     *
     * This function mutates the original TxHashSet by removing the specified value. It does not return a new TxHashSet reference.
     *
     * **Example** (Removing values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const txSet = yield* TxHashSet.make("a", "b", "c")
     *
     *   const removed = yield* TxHashSet.remove(txSet, "b")
     *   console.log(removed) // true (value existed and was removed)
     *   console.log(yield* TxHashSet.size(txSet)) // 2
     *   console.log(yield* TxHashSet.has(txSet, "b")) // false
     *
     *   // Removing non-existent value returns false
     *   const notRemoved = yield* TxHashSet.remove(txSet, "d")
     *   console.log(notRemoved) // false
     * })
     * ```
     *
     * @category mutations
     * @since 2.0.0
     */
    <V>(value: V): (self: TxHashSet<V>) => Effect.Effect<boolean>;
    /**
     * Removes a value from the TxHashSet.
     *
     * **Details**
     *
     * This function mutates the original TxHashSet by removing the specified value. It does not return a new TxHashSet reference.
     *
     * **Example** (Removing values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const txSet = yield* TxHashSet.make("a", "b", "c")
     *
     *   const removed = yield* TxHashSet.remove(txSet, "b")
     *   console.log(removed) // true (value existed and was removed)
     *   console.log(yield* TxHashSet.size(txSet)) // 2
     *   console.log(yield* TxHashSet.has(txSet, "b")) // false
     *
     *   // Removing non-existent value returns false
     *   const notRemoved = yield* TxHashSet.remove(txSet, "d")
     *   console.log(notRemoved) // false
     * })
     * ```
     *
     * @category mutations
     * @since 2.0.0
     */
    <V>(self: TxHashSet<V>, value: V): Effect.Effect<boolean>;
};
/**
 * Checks whether the TxHashSet contains the specified value.
 *
 * **Example** (Checking membership)
 *
 * ```ts
 * import { Effect, Equal, Hash, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const txSet = yield* TxHashSet.make("apple", "banana", "cherry")
 *
 *   console.log(yield* TxHashSet.has(txSet, "apple")) // true
 *   console.log(yield* TxHashSet.has(txSet, "grape")) // false
 *
 *   // Works with any type that implements Equal
 *   class Person implements Equal.Equal {
 *     constructor(readonly name: string) {}
 *
 *     [Equal.symbol](other: unknown) {
 *       return other instanceof Person && this.name === other.name
 *     }
 *
 *     [Hash.symbol](): number {
 *       return Hash.string(this.name)
 *     }
 *   }
 *
 *   const people = yield* TxHashSet.make(new Person("Alice"), new Person("Bob"))
 *   console.log(yield* TxHashSet.has(people, new Person("Alice"))) // true
 * })
 * ```
 *
 * @category elements
 * @since 2.0.0
 */
export declare const has: {
    /**
     * Checks whether the TxHashSet contains the specified value.
     *
     * **Example** (Checking membership)
     *
     * ```ts
     * import { Effect, Equal, Hash, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const txSet = yield* TxHashSet.make("apple", "banana", "cherry")
     *
     *   console.log(yield* TxHashSet.has(txSet, "apple")) // true
     *   console.log(yield* TxHashSet.has(txSet, "grape")) // false
     *
     *   // Works with any type that implements Equal
     *   class Person implements Equal.Equal {
     *     constructor(readonly name: string) {}
     *
     *     [Equal.symbol](other: unknown) {
     *       return other instanceof Person && this.name === other.name
     *     }
     *
     *     [Hash.symbol](): number {
     *       return Hash.string(this.name)
     *     }
     *   }
     *
     *   const people = yield* TxHashSet.make(new Person("Alice"), new Person("Bob"))
     *   console.log(yield* TxHashSet.has(people, new Person("Alice"))) // true
     * })
     * ```
     *
     * @category elements
     * @since 2.0.0
     */
    <V>(value: V): (self: TxHashSet<V>) => Effect.Effect<boolean>;
    /**
     * Checks whether the TxHashSet contains the specified value.
     *
     * **Example** (Checking membership)
     *
     * ```ts
     * import { Effect, Equal, Hash, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const txSet = yield* TxHashSet.make("apple", "banana", "cherry")
     *
     *   console.log(yield* TxHashSet.has(txSet, "apple")) // true
     *   console.log(yield* TxHashSet.has(txSet, "grape")) // false
     *
     *   // Works with any type that implements Equal
     *   class Person implements Equal.Equal {
     *     constructor(readonly name: string) {}
     *
     *     [Equal.symbol](other: unknown) {
     *       return other instanceof Person && this.name === other.name
     *     }
     *
     *     [Hash.symbol](): number {
     *       return Hash.string(this.name)
     *     }
     *   }
     *
     *   const people = yield* TxHashSet.make(new Person("Alice"), new Person("Bob"))
     *   console.log(yield* TxHashSet.has(people, new Person("Alice"))) // true
     * })
     * ```
     *
     * @category elements
     * @since 2.0.0
     */
    <V>(self: TxHashSet<V>, value: V): Effect.Effect<boolean>;
};
/**
 * Returns the number of values in the TxHashSet.
 *
 * **Example** (Getting the set size)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const empty = yield* TxHashSet.empty<string>()
 *   console.log(yield* TxHashSet.size(empty)) // 0
 *
 *   const small = yield* TxHashSet.make("a", "b")
 *   console.log(yield* TxHashSet.size(small)) // 2
 *
 *   const fromIterable = yield* TxHashSet.fromIterable(["x", "y", "z", "x", "y"])
 *   console.log(yield* TxHashSet.size(fromIterable)) // 3 (duplicates ignored)
 * })
 * ```
 *
 * @category getters
 * @since 2.0.0
 */
export declare const size: <V>(self: TxHashSet<V>) => Effect.Effect<number>;
/**
 * Checks whether the TxHashSet is empty.
 *
 * **Example** (Checking whether a set is empty)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const empty = yield* TxHashSet.empty<string>()
 *   console.log(yield* TxHashSet.isEmpty(empty)) // true
 *
 *   const nonEmpty = yield* TxHashSet.make("a")
 *   console.log(yield* TxHashSet.isEmpty(nonEmpty)) // false
 * })
 * ```
 *
 * @category getters
 * @since 2.0.0
 */
export declare const isEmpty: <V>(self: TxHashSet<V>) => Effect.Effect<boolean>;
/**
 * Removes all values from the TxHashSet.
 *
 * **Details**
 *
 * This function mutates the original TxHashSet by clearing all values. It does not return a new TxHashSet reference.
 *
 * **Example** (Clearing all values)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const txSet = yield* TxHashSet.make("a", "b", "c")
 *   console.log(yield* TxHashSet.size(txSet)) // 3
 *
 *   yield* TxHashSet.clear(txSet)
 *   console.log(yield* TxHashSet.size(txSet)) // 0
 *   console.log(yield* TxHashSet.isEmpty(txSet)) // true
 * })
 * ```
 *
 * @category mutations
 * @since 4.0.0
 */
export declare const clear: <V>(self: TxHashSet<V>) => Effect.Effect<void>;
/**
 * Creates the union of two TxHashSets, returning a new TxHashSet.
 *
 * **Example** (Combining sets with union)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const set1 = yield* TxHashSet.make("a", "b")
 *   const set2 = yield* TxHashSet.make("b", "c")
 *   const combined = yield* TxHashSet.union(set1, set2)
 *
 *   const values = yield* TxHashSet.toHashSet(combined)
 *   console.log(Array.from(values).sort()) // ["a", "b", "c"]
 *   console.log(yield* TxHashSet.size(combined)) // 3
 * })
 * ```
 *
 * @category combinators
 * @since 2.0.0
 */
export declare const union: {
    /**
     * Creates the union of two TxHashSets, returning a new TxHashSet.
     *
     * **Example** (Combining sets with union)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const set1 = yield* TxHashSet.make("a", "b")
     *   const set2 = yield* TxHashSet.make("b", "c")
     *   const combined = yield* TxHashSet.union(set1, set2)
     *
     *   const values = yield* TxHashSet.toHashSet(combined)
     *   console.log(Array.from(values).sort()) // ["a", "b", "c"]
     *   console.log(yield* TxHashSet.size(combined)) // 3
     * })
     * ```
     *
     * @category combinators
     * @since 2.0.0
     */
    <V1>(that: TxHashSet<V1>): <V0>(self: TxHashSet<V0>) => Effect.Effect<TxHashSet<V1 | V0>>;
    /**
     * Creates the union of two TxHashSets, returning a new TxHashSet.
     *
     * **Example** (Combining sets with union)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const set1 = yield* TxHashSet.make("a", "b")
     *   const set2 = yield* TxHashSet.make("b", "c")
     *   const combined = yield* TxHashSet.union(set1, set2)
     *
     *   const values = yield* TxHashSet.toHashSet(combined)
     *   console.log(Array.from(values).sort()) // ["a", "b", "c"]
     *   console.log(yield* TxHashSet.size(combined)) // 3
     * })
     * ```
     *
     * @category combinators
     * @since 2.0.0
     */
    <V0, V1>(self: TxHashSet<V0>, that: TxHashSet<V1>): Effect.Effect<TxHashSet<V0 | V1>>;
};
/**
 * Creates the intersection of two TxHashSets, returning a new TxHashSet.
 *
 * **Example** (Finding common values)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const set1 = yield* TxHashSet.make("a", "b", "c")
 *   const set2 = yield* TxHashSet.make("b", "c", "d")
 *   const common = yield* TxHashSet.intersection(set1, set2)
 *
 *   const values = yield* TxHashSet.toHashSet(common)
 *   console.log(Array.from(values).sort()) // ["b", "c"]
 *   console.log(yield* TxHashSet.size(common)) // 2
 * })
 * ```
 *
 * @category combinators
 * @since 2.0.0
 */
export declare const intersection: {
    /**
     * Creates the intersection of two TxHashSets, returning a new TxHashSet.
     *
     * **Example** (Finding common values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const set1 = yield* TxHashSet.make("a", "b", "c")
     *   const set2 = yield* TxHashSet.make("b", "c", "d")
     *   const common = yield* TxHashSet.intersection(set1, set2)
     *
     *   const values = yield* TxHashSet.toHashSet(common)
     *   console.log(Array.from(values).sort()) // ["b", "c"]
     *   console.log(yield* TxHashSet.size(common)) // 2
     * })
     * ```
     *
     * @category combinators
     * @since 2.0.0
     */
    <V1>(that: TxHashSet<V1>): <V0>(self: TxHashSet<V0>) => Effect.Effect<TxHashSet<V1 & V0>>;
    /**
     * Creates the intersection of two TxHashSets, returning a new TxHashSet.
     *
     * **Example** (Finding common values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const set1 = yield* TxHashSet.make("a", "b", "c")
     *   const set2 = yield* TxHashSet.make("b", "c", "d")
     *   const common = yield* TxHashSet.intersection(set1, set2)
     *
     *   const values = yield* TxHashSet.toHashSet(common)
     *   console.log(Array.from(values).sort()) // ["b", "c"]
     *   console.log(yield* TxHashSet.size(common)) // 2
     * })
     * ```
     *
     * @category combinators
     * @since 2.0.0
     */
    <V0, V1>(self: TxHashSet<V0>, that: TxHashSet<V1>): Effect.Effect<TxHashSet<V0 & V1>>;
};
/**
 * Creates the difference of two TxHashSets (elements in the first set that are not in the second), returning a new TxHashSet.
 *
 * **Example** (Finding values absent from another set)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const set1 = yield* TxHashSet.make("a", "b", "c")
 *   const set2 = yield* TxHashSet.make("b", "d")
 *   const diff = yield* TxHashSet.difference(set1, set2)
 *
 *   const values = yield* TxHashSet.toHashSet(diff)
 *   console.log(Array.from(values).sort()) // ["a", "c"]
 *   console.log(yield* TxHashSet.size(diff)) // 2
 * })
 * ```
 *
 * @category combinators
 * @since 2.0.0
 */
export declare const difference: {
    /**
     * Creates the difference of two TxHashSets (elements in the first set that are not in the second), returning a new TxHashSet.
     *
     * **Example** (Finding values absent from another set)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const set1 = yield* TxHashSet.make("a", "b", "c")
     *   const set2 = yield* TxHashSet.make("b", "d")
     *   const diff = yield* TxHashSet.difference(set1, set2)
     *
     *   const values = yield* TxHashSet.toHashSet(diff)
     *   console.log(Array.from(values).sort()) // ["a", "c"]
     *   console.log(yield* TxHashSet.size(diff)) // 2
     * })
     * ```
     *
     * @category combinators
     * @since 2.0.0
     */
    <V1>(that: TxHashSet<V1>): <V0>(self: TxHashSet<V0>) => Effect.Effect<TxHashSet<V0>>;
    /**
     * Creates the difference of two TxHashSets (elements in the first set that are not in the second), returning a new TxHashSet.
     *
     * **Example** (Finding values absent from another set)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const set1 = yield* TxHashSet.make("a", "b", "c")
     *   const set2 = yield* TxHashSet.make("b", "d")
     *   const diff = yield* TxHashSet.difference(set1, set2)
     *
     *   const values = yield* TxHashSet.toHashSet(diff)
     *   console.log(Array.from(values).sort()) // ["a", "c"]
     *   console.log(yield* TxHashSet.size(diff)) // 2
     * })
     * ```
     *
     * @category combinators
     * @since 2.0.0
     */
    <V0, V1>(self: TxHashSet<V0>, that: TxHashSet<V1>): Effect.Effect<TxHashSet<V0>>;
};
/**
 * Checks whether a TxHashSet is a subset of another TxHashSet.
 *
 * **Example** (Checking subset relationships)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const small = yield* TxHashSet.make("a", "b")
 *   const large = yield* TxHashSet.make("a", "b", "c", "d")
 *   const other = yield* TxHashSet.make("x", "y")
 *
 *   console.log(yield* TxHashSet.isSubset(small, large)) // true
 *   console.log(yield* TxHashSet.isSubset(large, small)) // false
 *   console.log(yield* TxHashSet.isSubset(small, other)) // false
 *   console.log(yield* TxHashSet.isSubset(small, small)) // true
 * })
 * ```
 *
 * @category elements
 * @since 4.0.0
 */
export declare const isSubset: {
    /**
     * Checks whether a TxHashSet is a subset of another TxHashSet.
     *
     * **Example** (Checking subset relationships)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const small = yield* TxHashSet.make("a", "b")
     *   const large = yield* TxHashSet.make("a", "b", "c", "d")
     *   const other = yield* TxHashSet.make("x", "y")
     *
     *   console.log(yield* TxHashSet.isSubset(small, large)) // true
     *   console.log(yield* TxHashSet.isSubset(large, small)) // false
     *   console.log(yield* TxHashSet.isSubset(small, other)) // false
     *   console.log(yield* TxHashSet.isSubset(small, small)) // true
     * })
     * ```
     *
     * @category elements
     * @since 4.0.0
     */
    <V1>(that: TxHashSet<V1>): <V0>(self: TxHashSet<V0>) => Effect.Effect<boolean>;
    /**
     * Checks whether a TxHashSet is a subset of another TxHashSet.
     *
     * **Example** (Checking subset relationships)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const small = yield* TxHashSet.make("a", "b")
     *   const large = yield* TxHashSet.make("a", "b", "c", "d")
     *   const other = yield* TxHashSet.make("x", "y")
     *
     *   console.log(yield* TxHashSet.isSubset(small, large)) // true
     *   console.log(yield* TxHashSet.isSubset(large, small)) // false
     *   console.log(yield* TxHashSet.isSubset(small, other)) // false
     *   console.log(yield* TxHashSet.isSubset(small, small)) // true
     * })
     * ```
     *
     * @category elements
     * @since 4.0.0
     */
    <V0, V1>(self: TxHashSet<V0>, that: TxHashSet<V1>): Effect.Effect<boolean>;
};
/**
 * Checks whether at least one value in the TxHashSet satisfies the predicate.
 *
 * **Example** (Testing whether some values match)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5)
 *
 *   console.log(yield* TxHashSet.some(numbers, (n) => n > 3)) // true
 *   console.log(yield* TxHashSet.some(numbers, (n) => n > 10)) // false
 *
 *   const empty = yield* TxHashSet.empty<number>()
 *   console.log(yield* TxHashSet.some(empty, (n) => n > 0)) // false
 * })
 * ```
 *
 * @category elements
 * @since 4.0.0
 */
export declare const some: {
    /**
     * Checks whether at least one value in the TxHashSet satisfies the predicate.
     *
     * **Example** (Testing whether some values match)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5)
     *
     *   console.log(yield* TxHashSet.some(numbers, (n) => n > 3)) // true
     *   console.log(yield* TxHashSet.some(numbers, (n) => n > 10)) // false
     *
     *   const empty = yield* TxHashSet.empty<number>()
     *   console.log(yield* TxHashSet.some(empty, (n) => n > 0)) // false
     * })
     * ```
     *
     * @category elements
     * @since 4.0.0
     */
    <V>(predicate: Predicate<V>): (self: TxHashSet<V>) => Effect.Effect<boolean>;
    /**
     * Checks whether at least one value in the TxHashSet satisfies the predicate.
     *
     * **Example** (Testing whether some values match)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5)
     *
     *   console.log(yield* TxHashSet.some(numbers, (n) => n > 3)) // true
     *   console.log(yield* TxHashSet.some(numbers, (n) => n > 10)) // false
     *
     *   const empty = yield* TxHashSet.empty<number>()
     *   console.log(yield* TxHashSet.some(empty, (n) => n > 0)) // false
     * })
     * ```
     *
     * @category elements
     * @since 4.0.0
     */
    <V>(self: TxHashSet<V>, predicate: Predicate<V>): Effect.Effect<boolean>;
};
/**
 * Checks whether all values in the TxHashSet satisfy the predicate.
 *
 * **Example** (Testing whether every value matches)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const numbers = yield* TxHashSet.make(2, 4, 6, 8)
 *
 *   console.log(yield* TxHashSet.every(numbers, (n) => n % 2 === 0)) // true
 *   console.log(yield* TxHashSet.every(numbers, (n) => n > 5)) // false
 *
 *   const empty = yield* TxHashSet.empty<number>()
 *   console.log(yield* TxHashSet.every(empty, (n) => n > 0)) // true (vacuously true)
 * })
 * ```
 *
 * @category elements
 * @since 4.0.0
 */
export declare const every: {
    /**
     * Checks whether all values in the TxHashSet satisfy the predicate.
     *
     * **Example** (Testing whether every value matches)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(2, 4, 6, 8)
     *
     *   console.log(yield* TxHashSet.every(numbers, (n) => n % 2 === 0)) // true
     *   console.log(yield* TxHashSet.every(numbers, (n) => n > 5)) // false
     *
     *   const empty = yield* TxHashSet.empty<number>()
     *   console.log(yield* TxHashSet.every(empty, (n) => n > 0)) // true (vacuously true)
     * })
     * ```
     *
     * @category elements
     * @since 4.0.0
     */
    <V>(predicate: Predicate<V>): (self: TxHashSet<V>) => Effect.Effect<boolean>;
    /**
     * Checks whether all values in the TxHashSet satisfy the predicate.
     *
     * **Example** (Testing whether every value matches)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(2, 4, 6, 8)
     *
     *   console.log(yield* TxHashSet.every(numbers, (n) => n % 2 === 0)) // true
     *   console.log(yield* TxHashSet.every(numbers, (n) => n > 5)) // false
     *
     *   const empty = yield* TxHashSet.empty<number>()
     *   console.log(yield* TxHashSet.every(empty, (n) => n > 0)) // true (vacuously true)
     * })
     * ```
     *
     * @category elements
     * @since 4.0.0
     */
    <V>(self: TxHashSet<V>, predicate: Predicate<V>): Effect.Effect<boolean>;
};
/**
 * Maps each value in the TxHashSet using the provided function, returning a new TxHashSet.
 *
 * **Example** (Mapping values)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const numbers = yield* TxHashSet.make(1, 2, 3)
 *   const doubled = yield* TxHashSet.map(numbers, (n) => n * 2)
 *
 *   const values = yield* TxHashSet.toHashSet(doubled)
 *   console.log(Array.from(values).sort()) // [2, 4, 6]
 *   console.log(yield* TxHashSet.size(doubled)) // 3
 *
 *   // Mapping can reduce size if function produces duplicates
 *   const strings = yield* TxHashSet.make("apple", "banana", "cherry")
 *   const lengths = yield* TxHashSet.map(strings, (s) => s.length)
 *   const lengthValues = yield* TxHashSet.toHashSet(lengths)
 *   console.log(Array.from(lengthValues).sort()) // [5, 6] (apple=5, banana=6, cherry=6)
 * })
 * ```
 *
 * @category mapping
 * @since 4.0.0
 */
export declare const map: {
    /**
     * Maps each value in the TxHashSet using the provided function, returning a new TxHashSet.
     *
     * **Example** (Mapping values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(1, 2, 3)
     *   const doubled = yield* TxHashSet.map(numbers, (n) => n * 2)
     *
     *   const values = yield* TxHashSet.toHashSet(doubled)
     *   console.log(Array.from(values).sort()) // [2, 4, 6]
     *   console.log(yield* TxHashSet.size(doubled)) // 3
     *
     *   // Mapping can reduce size if function produces duplicates
     *   const strings = yield* TxHashSet.make("apple", "banana", "cherry")
     *   const lengths = yield* TxHashSet.map(strings, (s) => s.length)
     *   const lengthValues = yield* TxHashSet.toHashSet(lengths)
     *   console.log(Array.from(lengthValues).sort()) // [5, 6] (apple=5, banana=6, cherry=6)
     * })
     * ```
     *
     * @category mapping
     * @since 4.0.0
     */
    <V, U>(f: (value: V) => U): (self: TxHashSet<V>) => Effect.Effect<TxHashSet<U>>;
    /**
     * Maps each value in the TxHashSet using the provided function, returning a new TxHashSet.
     *
     * **Example** (Mapping values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(1, 2, 3)
     *   const doubled = yield* TxHashSet.map(numbers, (n) => n * 2)
     *
     *   const values = yield* TxHashSet.toHashSet(doubled)
     *   console.log(Array.from(values).sort()) // [2, 4, 6]
     *   console.log(yield* TxHashSet.size(doubled)) // 3
     *
     *   // Mapping can reduce size if function produces duplicates
     *   const strings = yield* TxHashSet.make("apple", "banana", "cherry")
     *   const lengths = yield* TxHashSet.map(strings, (s) => s.length)
     *   const lengthValues = yield* TxHashSet.toHashSet(lengths)
     *   console.log(Array.from(lengthValues).sort()) // [5, 6] (apple=5, banana=6, cherry=6)
     * })
     * ```
     *
     * @category mapping
     * @since 4.0.0
     */
    <V, U>(self: TxHashSet<V>, f: (value: V) => U): Effect.Effect<TxHashSet<U>>;
};
/**
 * Filters the TxHashSet keeping only values that satisfy the predicate, returning a new TxHashSet.
 *
 * **Example** (Filtering values)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5, 6)
 *   const evens = yield* TxHashSet.filter(numbers, (n) => n % 2 === 0)
 *
 *   const values = yield* TxHashSet.toHashSet(evens)
 *   console.log(Array.from(values).sort()) // [2, 4, 6]
 *   console.log(yield* TxHashSet.size(evens)) // 3
 * })
 * ```
 *
 * @category filtering
 * @since 4.0.0
 */
export declare const filter: {
    /**
     * Filters the TxHashSet keeping only values that satisfy the predicate, returning a new TxHashSet.
     *
     * **Example** (Filtering values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5, 6)
     *   const evens = yield* TxHashSet.filter(numbers, (n) => n % 2 === 0)
     *
     *   const values = yield* TxHashSet.toHashSet(evens)
     *   console.log(Array.from(values).sort()) // [2, 4, 6]
     *   console.log(yield* TxHashSet.size(evens)) // 3
     * })
     * ```
     *
     * @category filtering
     * @since 4.0.0
     */
    <V, U extends V>(refinement: Refinement<NoInfer<V>, U>): (self: TxHashSet<V>) => Effect.Effect<TxHashSet<U>>;
    /**
     * Filters the TxHashSet keeping only values that satisfy the predicate, returning a new TxHashSet.
     *
     * **Example** (Filtering values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5, 6)
     *   const evens = yield* TxHashSet.filter(numbers, (n) => n % 2 === 0)
     *
     *   const values = yield* TxHashSet.toHashSet(evens)
     *   console.log(Array.from(values).sort()) // [2, 4, 6]
     *   console.log(yield* TxHashSet.size(evens)) // 3
     * })
     * ```
     *
     * @category filtering
     * @since 4.0.0
     */
    <V>(predicate: Predicate<NoInfer<V>>): (self: TxHashSet<V>) => Effect.Effect<TxHashSet<V>>;
    /**
     * Filters the TxHashSet keeping only values that satisfy the predicate, returning a new TxHashSet.
     *
     * **Example** (Filtering values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5, 6)
     *   const evens = yield* TxHashSet.filter(numbers, (n) => n % 2 === 0)
     *
     *   const values = yield* TxHashSet.toHashSet(evens)
     *   console.log(Array.from(values).sort()) // [2, 4, 6]
     *   console.log(yield* TxHashSet.size(evens)) // 3
     * })
     * ```
     *
     * @category filtering
     * @since 4.0.0
     */
    <V, U extends V>(self: TxHashSet<V>, refinement: Refinement<V, U>): Effect.Effect<TxHashSet<U>>;
    /**
     * Filters the TxHashSet keeping only values that satisfy the predicate, returning a new TxHashSet.
     *
     * **Example** (Filtering values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5, 6)
     *   const evens = yield* TxHashSet.filter(numbers, (n) => n % 2 === 0)
     *
     *   const values = yield* TxHashSet.toHashSet(evens)
     *   console.log(Array.from(values).sort()) // [2, 4, 6]
     *   console.log(yield* TxHashSet.size(evens)) // 3
     * })
     * ```
     *
     * @category filtering
     * @since 4.0.0
     */
    <V>(self: TxHashSet<V>, predicate: Predicate<V>): Effect.Effect<TxHashSet<V>>;
};
/**
 * Reduces the TxHashSet to a single value by iterating through the values and applying an accumulator function.
 *
 * **Example** (Reducing values)
 *
 * ```ts
 * import { Effect, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5)
 *   const sum = yield* TxHashSet.reduce(numbers, 0, (acc, n) => acc + n)
 *
 *   console.log(sum) // 15
 *
 *   const strings = yield* TxHashSet.make("a", "b", "c")
 *   const concatenated = yield* TxHashSet.reduce(strings, "", (acc, s) => acc + s)
 *   console.log(concatenated) // Order may vary: "abc", "bac", etc.
 * })
 * ```
 *
 * @category folding
 * @since 2.0.0
 */
export declare const reduce: {
    /**
     * Reduces the TxHashSet to a single value by iterating through the values and applying an accumulator function.
     *
     * **Example** (Reducing values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5)
     *   const sum = yield* TxHashSet.reduce(numbers, 0, (acc, n) => acc + n)
     *
     *   console.log(sum) // 15
     *
     *   const strings = yield* TxHashSet.make("a", "b", "c")
     *   const concatenated = yield* TxHashSet.reduce(strings, "", (acc, s) => acc + s)
     *   console.log(concatenated) // Order may vary: "abc", "bac", etc.
     * })
     * ```
     *
     * @category folding
     * @since 2.0.0
     */
    <V, U>(zero: U, f: (accumulator: U, value: V) => U): (self: TxHashSet<V>) => Effect.Effect<U>;
    /**
     * Reduces the TxHashSet to a single value by iterating through the values and applying an accumulator function.
     *
     * **Example** (Reducing values)
     *
     * ```ts
     * import { Effect, TxHashSet } from "effect"
     *
     * const program = Effect.gen(function*() {
     *   const numbers = yield* TxHashSet.make(1, 2, 3, 4, 5)
     *   const sum = yield* TxHashSet.reduce(numbers, 0, (acc, n) => acc + n)
     *
     *   console.log(sum) // 15
     *
     *   const strings = yield* TxHashSet.make("a", "b", "c")
     *   const concatenated = yield* TxHashSet.reduce(strings, "", (acc, s) => acc + s)
     *   console.log(concatenated) // Order may vary: "abc", "bac", etc.
     * })
     * ```
     *
     * @category folding
     * @since 2.0.0
     */
    <V, U>(self: TxHashSet<V>, zero: U, f: (accumulator: U, value: V) => U): Effect.Effect<U>;
};
/**
 * Converts the TxHashSet to an immutable HashSet snapshot.
 *
 * **Example** (Taking a HashSet snapshot)
 *
 * ```ts
 * import { Effect, HashSet, TxHashSet } from "effect"
 *
 * const program = Effect.gen(function*() {
 *   const txSet = yield* TxHashSet.make("x", "y", "z")
 *   const hashSet = yield* TxHashSet.toHashSet(txSet)
 *
 *   console.log(HashSet.size(hashSet)) // 3
 *   console.log(HashSet.has(hashSet, "y")) // true
 *
 *   // hashSet is a snapshot - modifications to txSet don't affect it
 *   yield* TxHashSet.add(txSet, "w")
 *   console.log(HashSet.size(hashSet)) // 3 (unchanged)
 *   console.log(yield* TxHashSet.size(txSet)) // 4
 * })
 * ```
 *
 * @category converting
 * @since 2.0.0
 */
export declare const toHashSet: <V>(self: TxHashSet<V>) => Effect.Effect<HashSet.HashSet<V>>;
export {};
//# sourceMappingURL=TxHashSet.d.ts.map