import { type Inspectable } from "./Inspectable.ts";
import * as MutableHashMap from "./MutableHashMap.ts";
import type { Pipeable } from "./Pipeable.ts";
declare const TypeId = "~effect/MutableHashSet";
/**
 * A mutable hash set for storing unique values with Effect structural equality
 * support.
 *
 * **When to use**
 *
 * Use to store and mutate a collection of unique values with Effect hashing and
 * equality semantics.
 *
 * **Details**
 *
 * Operations mutate the set in place. Values that implement `Equal` / `Hash`
 * can be de-duplicated structurally; other values use normal JavaScript
 * reference or primitive equality.
 *
 * **Example** (Using a mutable hash set)
 *
 * ```ts import.meta.vitest
 * import { MutableHashSet } from "effect"
 *
 * // Create a mutable hash set
 * const set: MutableHashSet.MutableHashSet<string> = MutableHashSet.make(
 *   "apple",
 *   "banana"
 * )
 *
 * // Add elements
 * MutableHashSet.add(set, "cherry")
 *
 * // Check if elements exist
 * MutableHashSet.has(set, "apple") // => true
 * MutableHashSet.has(set, "grape") // => false
 *
 * // Collect the iterator values
 * Array.from(set) // => ["apple", "banana", "cherry"]
 *
 * // Get size
 * MutableHashSet.size(set) // => 3
 * ```
 *
 * @stability stable
 * @category models
 * @since 2.0.0
 */
export interface MutableHashSet<out V> extends Iterable<V>, Pipeable, Inspectable {
    readonly [TypeId]: typeof TypeId;
    readonly keyMap: MutableHashMap.MutableHashMap<V, boolean>;
}
/**
 * Checks whether the specified value is a `MutableHashSet`, `false` otherwise.
 *
 * **When to use**
 *
 * Use to narrow an unknown value before treating it as a mutable hash set.
 *
 * **Details**
 *
 * The check looks for the `MutableHashSet` runtime marker.
 *
 * **Gotchas**
 *
 * Native `Set` values do not satisfy this check.
 *
 * @see {@link MutableHashSet} for the mutable hash set interface
 *
 * @stability stable
 * @category guards
 * @since 4.0.0
 */
export declare const isMutableHashSet: <V>(value: unknown) => value is MutableHashSet<V>;
/**
 * Creates an empty MutableHashSet.
 *
 * **When to use**
 *
 * Use to create a fresh mutable set before adding values over time.
 *
 * **Details**
 *
 * Each call returns a new empty set backed by an empty `MutableHashMap`.
 *
 * **Example** (Creating an empty set)
 *
 * ```ts import.meta.vitest
 * import { MutableHashSet } from "effect"
 *
 * const set = MutableHashSet.empty<string>()
 *
 * // Add some values
 * MutableHashSet.add(set, "apple")
 * MutableHashSet.add(set, "banana")
 * MutableHashSet.add(set, "apple") // Duplicate, no effect
 *
 * MutableHashSet.size(set) // => 2
 * Array.from(set) // => ["apple", "banana"]
 * ```
 *
 * @see {@link make} for creating a set from explicit values
 * @see {@link fromIterable} for creating a set from an iterable of values
 * @see {@link clear} for emptying an existing mutable set
 *
 * @stability stable
 * @category constructors
 * @since 2.0.0
 */
export declare const empty: <K = never>() => MutableHashSet<K>;
/**
 * Creates a MutableHashSet from an iterable collection of values.
 * Duplicates are automatically removed.
 *
 * **When to use**
 *
 * Use to build a mutable hash set from any iterable of values.
 *
 * **Example** (Creating a set from an iterable)
 *
 * ```ts import.meta.vitest
 * import { MutableHashSet } from "effect"
 *
 * const values = ["apple", "banana", "apple", "cherry", "banana"]
 * const set = MutableHashSet.fromIterable(values)
 *
 * MutableHashSet.size(set) // => 3
 * Array.from(set) // => ["apple", "banana", "cherry"]
 *
 * // Works with any iterable
 * MutableHashSet.size(MutableHashSet.fromIterable(new Set([1, 2, 3]))) // => 3
 *
 * // From string characters
 * Array.from(MutableHashSet.fromIterable("hello")) // => ["h", "e", "l", "o"]
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 2.0.0
 */
export declare const fromIterable: <K = never>(keys: Iterable<K>) => MutableHashSet<K>;
/**
 * Creates a MutableHashSet from a variable number of values.
 * Duplicates are automatically removed.
 *
 * **When to use**
 *
 * Use to build a mutable hash set from explicit values.
 *
 * **Example** (Creating a set from values)
 *
 * ```ts import.meta.vitest
 * import { MutableHashSet } from "effect"
 *
 * const set = MutableHashSet.make("apple", "banana", "apple", "cherry")
 *
 * MutableHashSet.size(set) // => 3
 * Array.from(set) // => ["apple", "banana", "cherry"]
 *
 * // With numbers
 * const numbers = MutableHashSet.make(1, 2, 3, 2, 1)
 * MutableHashSet.size(numbers) // => 3
 * Array.from(numbers) // => [1, 2, 3]
 *
 * // Mixed types
 * MutableHashSet.size(MutableHashSet.make("hello", 42, true, "hello")) // => 3
 * ```
 *
 * @stability stable
 * @category constructors
 * @since 2.0.0
 */
export declare const make: <Keys extends ReadonlyArray<unknown>>(...keys: Keys) => MutableHashSet<Keys[number]>;
/**
 * Adds a value to the MutableHashSet, mutating the set in place.
 * If the value already exists, the set remains unchanged.
 *
 * **When to use**
 *
 * Use to insert a value into a mutable set while keeping uniqueness.
 *
 * **Example** (Adding values)
 *
 * ```ts import.meta.vitest
 * import { MutableHashSet } from "effect"
 *
 * const set = MutableHashSet.empty<string>()
 *
 * // Add new values
 * MutableHashSet.add(set, "apple")
 * MutableHashSet.add(set, "banana")
 *
 * MutableHashSet.size(set) // => 2
 * MutableHashSet.has(set, "apple") // => true
 *
 * // Add duplicate (no effect)
 * MutableHashSet.add(set, "apple")
 * MutableHashSet.size(set) // => 2
 *
 * // Pipe-able version
 * const addFruit = MutableHashSet.add("cherry")
 * addFruit(set)
 * MutableHashSet.size(set) // => 3
 * ```
 *
 * @stability stable
 * @category mutations
 * @since 2.0.0
 */
export declare const add: {
    /**
     * Adds a value to the MutableHashSet, mutating the set in place.
     * If the value already exists, the set remains unchanged.
     *
     * **When to use**
     *
     * Use to insert a value into a mutable set while keeping uniqueness.
     *
     * **Example** (Adding values)
     *
     * ```ts import.meta.vitest
     * import { MutableHashSet } from "effect"
     *
     * const set = MutableHashSet.empty<string>()
     *
     * // Add new values
     * MutableHashSet.add(set, "apple")
     * MutableHashSet.add(set, "banana")
     *
     * MutableHashSet.size(set) // => 2
     * MutableHashSet.has(set, "apple") // => true
     *
     * // Add duplicate (no effect)
     * MutableHashSet.add(set, "apple")
     * MutableHashSet.size(set) // => 2
     *
     * // Pipe-able version
     * const addFruit = MutableHashSet.add("cherry")
     * addFruit(set)
     * MutableHashSet.size(set) // => 3
     * ```
     *
     * @stability stable
     * @category mutations
     * @since 2.0.0
     */
    <V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>;
    /**
     * Adds a value to the MutableHashSet, mutating the set in place.
     * If the value already exists, the set remains unchanged.
     *
     * **When to use**
     *
     * Use to insert a value into a mutable set while keeping uniqueness.
     *
     * **Example** (Adding values)
     *
     * ```ts import.meta.vitest
     * import { MutableHashSet } from "effect"
     *
     * const set = MutableHashSet.empty<string>()
     *
     * // Add new values
     * MutableHashSet.add(set, "apple")
     * MutableHashSet.add(set, "banana")
     *
     * MutableHashSet.size(set) // => 2
     * MutableHashSet.has(set, "apple") // => true
     *
     * // Add duplicate (no effect)
     * MutableHashSet.add(set, "apple")
     * MutableHashSet.size(set) // => 2
     *
     * // Pipe-able version
     * const addFruit = MutableHashSet.add("cherry")
     * addFruit(set)
     * MutableHashSet.size(set) // => 3
     * ```
     *
     * @stability stable
     * @category mutations
     * @since 2.0.0
     */
    <V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>;
};
/**
 * Checks whether the MutableHashSet contains the specified value.
 *
 * **When to use**
 *
 * Use to test whether a mutable set currently contains a value.
 *
 * **Details**
 *
 * Membership follows the same hashing and equality rules as the underlying
 * `MutableHashMap`.
 *
 * **Example** (Checking for a value)
 *
 * ```ts import.meta.vitest
 * import { MutableHashSet } from "effect"
 *
 * const set = MutableHashSet.make("apple", "banana", "cherry")
 *
 * MutableHashSet.has(set, "apple") // => true
 * MutableHashSet.has(set, "grape") // => false
 *
 * // Pipe-able version
 * const hasApple = MutableHashSet.has("apple")
 * hasApple(set) // => true
 *
 * // Check after adding
 * MutableHashSet.add(set, "grape")
 * MutableHashSet.has(set, "grape") // => true
 * ```
 *
 * @see {@link add} for adding a value to the set
 * @see {@link remove} for removing a value from the set
 *
 * @stability stable
 * @category predicates
 * @since 2.0.0
 */
export declare const has: {
    /**
     * Checks whether the MutableHashSet contains the specified value.
     *
     * **When to use**
     *
     * Use to test whether a mutable set currently contains a value.
     *
     * **Details**
     *
     * Membership follows the same hashing and equality rules as the underlying
     * `MutableHashMap`.
     *
     * **Example** (Checking for a value)
     *
     * ```ts import.meta.vitest
     * import { MutableHashSet } from "effect"
     *
     * const set = MutableHashSet.make("apple", "banana", "cherry")
     *
     * MutableHashSet.has(set, "apple") // => true
     * MutableHashSet.has(set, "grape") // => false
     *
     * // Pipe-able version
     * const hasApple = MutableHashSet.has("apple")
     * hasApple(set) // => true
     *
     * // Check after adding
     * MutableHashSet.add(set, "grape")
     * MutableHashSet.has(set, "grape") // => true
     * ```
     *
     * @see {@link add} for adding a value to the set
     * @see {@link remove} for removing a value from the set
     *
     * @stability stable
     * @category predicates
     * @since 2.0.0
     */
    <V>(key: V): (self: MutableHashSet<V>) => boolean;
    /**
     * Checks whether the MutableHashSet contains the specified value.
     *
     * **When to use**
     *
     * Use to test whether a mutable set currently contains a value.
     *
     * **Details**
     *
     * Membership follows the same hashing and equality rules as the underlying
     * `MutableHashMap`.
     *
     * **Example** (Checking for a value)
     *
     * ```ts import.meta.vitest
     * import { MutableHashSet } from "effect"
     *
     * const set = MutableHashSet.make("apple", "banana", "cherry")
     *
     * MutableHashSet.has(set, "apple") // => true
     * MutableHashSet.has(set, "grape") // => false
     *
     * // Pipe-able version
     * const hasApple = MutableHashSet.has("apple")
     * hasApple(set) // => true
     *
     * // Check after adding
     * MutableHashSet.add(set, "grape")
     * MutableHashSet.has(set, "grape") // => true
     * ```
     *
     * @see {@link add} for adding a value to the set
     * @see {@link remove} for removing a value from the set
     *
     * @stability stable
     * @category predicates
     * @since 2.0.0
     */
    <V>(self: MutableHashSet<V>, key: V): boolean;
};
/**
 * Removes the specified value from the MutableHashSet, mutating the set in place.
 * If the value doesn't exist, the set remains unchanged.
 *
 * **When to use**
 *
 * Use to delete a value from a mutable set if it is present.
 *
 * **Example** (Removing a value)
 *
 * ```ts import.meta.vitest
 * import { MutableHashSet } from "effect"
 *
 * const set = MutableHashSet.make("apple", "banana", "cherry")
 *
 * MutableHashSet.size(set) // => 3
 *
 * // Remove existing value
 * MutableHashSet.remove(set, "banana")
 * MutableHashSet.size(set) // => 2
 * MutableHashSet.has(set, "banana") // => false
 *
 * // Remove non-existent value (no effect)
 * MutableHashSet.remove(set, "grape")
 * MutableHashSet.size(set) // => 2
 *
 * // Pipe-able version
 * const removeFruit = MutableHashSet.remove("apple")
 * removeFruit(set)
 * MutableHashSet.size(set) // => 1
 * ```
 *
 * @stability stable
 * @category mutations
 * @since 2.0.0
 */
export declare const remove: {
    /**
     * Removes the specified value from the MutableHashSet, mutating the set in place.
     * If the value doesn't exist, the set remains unchanged.
     *
     * **When to use**
     *
     * Use to delete a value from a mutable set if it is present.
     *
     * **Example** (Removing a value)
     *
     * ```ts import.meta.vitest
     * import { MutableHashSet } from "effect"
     *
     * const set = MutableHashSet.make("apple", "banana", "cherry")
     *
     * MutableHashSet.size(set) // => 3
     *
     * // Remove existing value
     * MutableHashSet.remove(set, "banana")
     * MutableHashSet.size(set) // => 2
     * MutableHashSet.has(set, "banana") // => false
     *
     * // Remove non-existent value (no effect)
     * MutableHashSet.remove(set, "grape")
     * MutableHashSet.size(set) // => 2
     *
     * // Pipe-able version
     * const removeFruit = MutableHashSet.remove("apple")
     * removeFruit(set)
     * MutableHashSet.size(set) // => 1
     * ```
     *
     * @stability stable
     * @category mutations
     * @since 2.0.0
     */
    <V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>;
    /**
     * Removes the specified value from the MutableHashSet, mutating the set in place.
     * If the value doesn't exist, the set remains unchanged.
     *
     * **When to use**
     *
     * Use to delete a value from a mutable set if it is present.
     *
     * **Example** (Removing a value)
     *
     * ```ts import.meta.vitest
     * import { MutableHashSet } from "effect"
     *
     * const set = MutableHashSet.make("apple", "banana", "cherry")
     *
     * MutableHashSet.size(set) // => 3
     *
     * // Remove existing value
     * MutableHashSet.remove(set, "banana")
     * MutableHashSet.size(set) // => 2
     * MutableHashSet.has(set, "banana") // => false
     *
     * // Remove non-existent value (no effect)
     * MutableHashSet.remove(set, "grape")
     * MutableHashSet.size(set) // => 2
     *
     * // Pipe-able version
     * const removeFruit = MutableHashSet.remove("apple")
     * removeFruit(set)
     * MutableHashSet.size(set) // => 1
     * ```
     *
     * @stability stable
     * @category mutations
     * @since 2.0.0
     */
    <V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>;
};
/**
 * Returns the number of unique values in the MutableHashSet.
 *
 * **When to use**
 *
 * Use to read how many unique values are currently stored in the set.
 *
 * **Example** (Checking set size)
 *
 * ```ts import.meta.vitest
 * import { MutableHashSet } from "effect"
 *
 * const set = MutableHashSet.empty<string>()
 * MutableHashSet.size(set) // => 0
 *
 * MutableHashSet.add(set, "apple")
 * MutableHashSet.add(set, "banana")
 * MutableHashSet.add(set, "apple") // Duplicate
 * MutableHashSet.size(set) // => 2
 *
 * MutableHashSet.remove(set, "apple")
 * MutableHashSet.size(set) // => 1
 *
 * MutableHashSet.clear(set)
 * MutableHashSet.size(set) // => 0
 * ```
 *
 * @stability stable
 * @category getters
 * @since 2.0.0
 */
export declare const size: <V>(self: MutableHashSet<V>) => number;
/**
 * Removes all values from the MutableHashSet, mutating the set in place.
 * The set becomes empty after this operation.
 *
 * **When to use**
 *
 * Use to empty a mutable set while keeping the same set instance.
 *
 * **Example** (Clearing all values)
 *
 * ```ts import.meta.vitest
 * import { MutableHashSet } from "effect"
 *
 * const set = MutableHashSet.make("apple", "banana", "cherry")
 *
 * MutableHashSet.size(set) // => 3
 *
 * // Clear all values
 * MutableHashSet.clear(set)
 *
 * MutableHashSet.size(set) // => 0
 * MutableHashSet.has(set, "apple") // => false
 * Array.from(set) // => []
 *
 * // Can still add new values after clearing
 * MutableHashSet.add(set, "new")
 * MutableHashSet.size(set) // => 1
 * ```
 *
 * @stability stable
 * @category mutations
 * @since 2.0.0
 */
export declare const clear: <V>(self: MutableHashSet<V>) => MutableHashSet<V>;
export {};
//# sourceMappingURL=MutableHashSet.d.ts.map