data-structure-typed 2.3.0 → 2.4.0

package/dist/types/data-structures/binary-tree/binary-tree.d.ts

@@ -291,14 +291,14 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @returns True if duplicates are allowed, false otherwise.
      */
     get isDuplicate(): boolean;
-    protected _store: Map<K, V | undefined>;
+    protected _store: Map<K, BinaryTreeNode<K, V>>;
     /**
      * Gets the external value store (used in Map mode).
      * @remarks Time O(1)
      *
      * @returns The map storing key-value pairs.
      */
-    get store(): Map<K, V | undefined>;
+    get store(): Map<K, BinaryTreeNode<K, V>>;
     protected _root?: BinaryTreeNode<K, V> | null | undefined;
     /**
      * Gets the root node of the tree.
@@ -792,7 +792,7 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param value - The value.
      * @returns True if successful.
      */
-    protected _setValue(key: K | null | undefined, value: V | undefined): false | Map<K, V | undefined>;
+    protected _setValue(key: K | null | undefined, value: V | undefined): boolean;
     /**
      * (Protected) Clears all nodes from the tree.
      * @remarks Time O(1)

package/dist/types/data-structures/binary-tree/index.d.ts

@@ -4,7 +4,7 @@ export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
 export * from './red-black-tree';
-export * from './avl-tree-multi-map';
 export * from './tree-multi-map';
-export * from './tree-counter';
-export * from './avl-tree-counter';
+export * from './tree-set';
+export * from './tree-map';
+export * from './tree-multi-set';

package/dist/types/data-structures/binary-tree/tree-map.d.ts

@@ -0,0 +1,177 @@
+/**
+ * TreeMap (ordered map) — a restricted, native-like API backed by RedBlackTree.
+ *
+ * Design goals:
+ * - No node exposure (no node inputs/outputs)
+ * - Native Map-like surface + Java NavigableMap-like helpers
+ * - Strict default comparator (number/string/Date), otherwise require comparator
+ */
+import type { Comparator } from '../../types';
+import type { TreeMapEntryCallback, TreeMapOptions, TreeMapRangeOptions, TreeMapReduceCallback } from '../../types';
+/**
+ * An ordered Map backed by a red-black tree.
+ *
+ * - Iteration order is ascending by key.
+ * - No node exposure: all APIs use keys/values only.
+ */
+export declare class TreeMap<K = any, V = any> implements Iterable<[K, V | undefined]> {
+    #private;
+    /**
+     * Create a TreeMap from an iterable of `[key, value]` entries.
+     *
+     * @throws {TypeError} If any entry is not a 2-tuple-like value, or when using the default comparator
+     * and encountering unsupported/invalid keys (e.g. `NaN`, invalid `Date`).
+     */
+    constructor(entries?: Iterable<[K, V | undefined]>, options?: TreeMapOptions<K>);
+    /**
+     * Create the strict default comparator.
+     *
+     * Supports:
+     * - `number` (rejects `NaN`; treats `-0` and `0` as equal)
+     * - `string`
+     * - `Date` (orders by `getTime()`, rejects invalid dates)
+     *
+     * For other key types, a custom comparator must be provided.
+     */
+    static createDefaultComparator<K>(): Comparator<K>;
+    private _validateKey;
+    /**
+     * Number of entries in the map.
+     */
+    get size(): number;
+    /**
+     * Whether the map is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Set or overwrite a value for a key.
+     * @remarks Expected time O(log n)
+     */
+    set(key: K, value: V | undefined): this;
+    /**
+     * Get the value under a key.
+     * @remarks Expected time O(log n)
+     */
+    get(key: K): V | undefined;
+    /**
+     * Test whether a key exists.
+     * @remarks Expected time O(log n)
+     */
+    has(key: K): boolean;
+    /**
+     * Delete a key.
+     * @returns `true` if the key existed; otherwise `false`.
+     * @remarks Expected time O(log n)
+     */
+    delete(key: K): boolean;
+    /**
+     * Remove all entries.
+     */
+    clear(): void;
+    /**
+     * Iterate over keys in ascending order.
+     */
+    keys(): IterableIterator<K>;
+    private _entryFromKey;
+    /**
+     * Iterate over values in ascending key order.
+     *
+     * Note: values may be `undefined` (TreeMap allows storing `undefined`, like native `Map`).
+     */
+    values(): IterableIterator<V | undefined>;
+    /**
+     * Iterate over `[key, value]` entries in ascending key order.
+     *
+     * Note: values may be `undefined`.
+     */
+    entries(): IterableIterator<[K, V | undefined]>;
+    [Symbol.iterator](): IterableIterator<[K, V | undefined]>;
+    /**
+     * Visit each entry in ascending key order.
+     *
+     * Note: callback value may be `undefined`.
+     */
+    forEach(cb: (value: V | undefined, key: K, map: TreeMap<K, V>) => void, thisArg?: any): void;
+    /**
+     * Create a new TreeMap by mapping each entry to a new `[key, value]` entry.
+     *
+     * This mirrors `RedBlackTree.map`: mapping produces a new ordered container.
+     * @remarks Time O(n log n) expected, Space O(n)
+     */
+    map<MK, MV>(callbackfn: TreeMapEntryCallback<K, V, [MK, MV], TreeMap<K, V>>, options?: TreeMapOptions<MK>, thisArg?: unknown): TreeMap<MK, MV>;
+    /**
+     * Create a new TreeMap containing only entries that satisfy the predicate.
+     * @remarks Time O(n log n) expected, Space O(n)
+     */
+    filter(callbackfn: TreeMapEntryCallback<K, V, boolean, TreeMap<K, V>>, thisArg?: unknown): TreeMap<K, V>;
+    /**
+     * Reduce entries into a single accumulator.
+     * @remarks Time O(n), Space O(1)
+     */
+    reduce<A>(callbackfn: TreeMapReduceCallback<K, V, A, TreeMap<K, V>>, initialValue: A): A;
+    /**
+     * Test whether all entries satisfy a predicate.
+     * @remarks Time O(n), Space O(1)
+     */
+    every(callbackfn: TreeMapEntryCallback<K, V, boolean, TreeMap<K, V>>, thisArg?: unknown): boolean;
+    /**
+     * Test whether any entry satisfies a predicate.
+     * @remarks Time O(n), Space O(1)
+     */
+    some(callbackfn: TreeMapEntryCallback<K, V, boolean, TreeMap<K, V>>, thisArg?: unknown): boolean;
+    /**
+     * Find the first entry that satisfies a predicate.
+     * @returns The first matching `[key, value]` tuple, or `undefined`.
+     * @remarks Time O(n), Space O(1)
+     */
+    find(callbackfn: TreeMapEntryCallback<K, V, boolean, TreeMap<K, V>>, thisArg?: unknown): [K, V | undefined] | undefined;
+    /**
+     * Materialize the map into an array of `[key, value]` tuples.
+     * @remarks Time O(n), Space O(n)
+     */
+    toArray(): Array<[K, V | undefined]>;
+    /**
+     * Print a human-friendly representation.
+     * @remarks Time O(n), Space O(n)
+     */
+    print(): void;
+    /**
+     * Smallest entry by key.
+     */
+    first(): [K, V | undefined] | undefined;
+    /**
+     * Largest entry by key.
+     */
+    last(): [K, V | undefined] | undefined;
+    /**
+     * Remove and return the smallest entry.
+     */
+    pollFirst(): [K, V | undefined] | undefined;
+    /**
+     * Remove and return the largest entry.
+     */
+    pollLast(): [K, V | undefined] | undefined;
+    /**
+     * Smallest entry whose key is >= the given key.
+     */
+    ceiling(key: K): [K, V | undefined] | undefined;
+    /**
+     * Largest entry whose key is <= the given key.
+     */
+    floor(key: K): [K, V | undefined] | undefined;
+    /**
+     * Smallest entry whose key is > the given key.
+     */
+    higher(key: K): [K, V | undefined] | undefined;
+    /**
+     * Largest entry whose key is < the given key.
+     */
+    lower(key: K): [K, V | undefined] | undefined;
+    /**
+     * Return all entries in a given key range.
+     *
+     * @param range `[low, high]`
+     * @param options Inclusive/exclusive bounds (defaults to inclusive).
+     */
+    rangeSearch(range: [K, K], options?: TreeMapRangeOptions): Array<[K, V | undefined]>;
+}

package/dist/types/data-structures/binary-tree/tree-multi-map.d.ts

@@ -2,118 +2,27 @@
  * data-structure-typed
  *
  * @author Pablo Zeng
- * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
+ * @copyright Copyright (c) 2022 Pablo Zeng
  * @license MIT License
  */
-import type { ElemOf, EntryCallback, FamilyPosition, RBTNColor, TreeMultiMapOptions } from '../../types';
-import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
-import { IBinaryTree } from '../../interfaces';
+import type { Comparator, TreeMultiMapOptions } from '../../types';
+import { RedBlackTreeNode } from './red-black-tree';
 /**
- * Node used by TreeMultiMap; stores the key with a bucket of values (array).
- * @remarks Time O(1), Space O(1)
- * @template K
- * @template V
+ * Node type used by TreeMultiMap (alias to RedBlackTreeNode for backward compatibility).
+ *
+ * @deprecated Direct node manipulation is discouraged. Use TreeMultiMap methods instead.
  */
-export declare class TreeMultiMapNode<K = any, V = any> {
-    key: K;
-    value?: V[];
-    parent?: TreeMultiMapNode<K, V>;
-    /**
-     * Create a TreeMultiMap node with an optional value bucket.
-     * @remarks Time O(1), Space O(1)
-     * @param key - Key of the node.
-     * @param [value] - Initial array of values.
-     * @returns New TreeMultiMapNode instance.
-     */
-    constructor(key: K, value?: V[], color?: RBTNColor);
-    _left?: TreeMultiMapNode<K, V> | null | undefined;
-    /**
-     * Get the left child pointer.
-     * @remarks Time O(1), Space O(1)
-     * @returns Left child node, or null/undefined.
-     */
-    get left(): TreeMultiMapNode<K, V> | null | undefined;
-    /**
-     * Set the left child and update its parent pointer.
-     * @remarks Time O(1), Space O(1)
-     * @param v - New left child node, or null/undefined.
-     * @returns void
-     */
-    set left(v: TreeMultiMapNode<K, V> | null | undefined);
-    _right?: TreeMultiMapNode<K, V> | null | undefined;
-    /**
-     * Get the right child pointer.
-     * @remarks Time O(1), Space O(1)
-     * @returns Right child node, or null/undefined.
-     */
-    get right(): TreeMultiMapNode<K, V> | null | undefined;
-    /**
-     * Set the right child and update its parent pointer.
-     * @remarks Time O(1), Space O(1)
-     * @param v - New right child node, or null/undefined.
-     * @returns void
-     */
-    set right(v: TreeMultiMapNode<K, V> | null | undefined);
-    _height: number;
-    /**
-     * Gets the height of the node (used in self-balancing trees).
-     * @remarks Time O(1), Space O(1)
-     *
-     * @returns The height.
-     */
-    get height(): number;
-    /**
-     * Sets the height of the node.
-     * @remarks Time O(1), Space O(1)
-     *
-     * @param value - The new height.
-     */
-    set height(value: number);
-    _color: RBTNColor;
-    /**
-     * Gets the color of the node (used in Red-Black trees).
-     * @remarks Time O(1), Space O(1)
-     *
-     * @returns The node's color.
-     */
-    get color(): RBTNColor;
-    /**
-     * Sets the color of the node.
-     * @remarks Time O(1), Space O(1)
-     *
-     * @param value - The new color.
-     */
-    set color(value: RBTNColor);
-    _count: number;
-    /**
-     * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
-     * @remarks Time O(1), Space O(1)
-     *
-     * @returns The subtree node count.
-     */
-    get count(): number;
-    /**
-     * Sets the count of nodes in the subtree.
-     * @remarks Time O(1), Space O(1)
-     *
-     * @param value - The new count.
-     */
-    set count(value: number);
-    /**
-     * Gets the position of the node relative to its parent.
-     * @remarks Time O(1), Space O(1)
-     *
-     * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
-     */
-    get familyPosition(): FamilyPosition;
+export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]> {
+    constructor(key: K, value?: V[]);
 }
 /**
- * Red-Black Tree–based multimap (key → array of values). Preserves O(log N) updates and supports map-like mode.
- * @remarks Time O(1), Space O(1)
- * @template K
- * @template V
- * @template R
+ * TreeMultiMap (ordered MultiMap) — key → bucket (Array of values).
  *
+ * Semantics (RFC):
+ * - Bucketed design: each key appears once; duplicates live in the bucket.
+ * - `get(key)` returns a **live** bucket reference.
+ * - Default iteration yields bucket entries: `[K, V[]]`.
+ * - Navigable operations (`first/last/ceiling/...`) return entry tuples like TreeMap.
  * @example
  * // players ranked by score with their equipment
  *  type Equipment = {
@@ -241,7 +150,7 @@ export declare class TreeMultiMapNode<K = any, V = any> {
  *       isMapMode: false
  *     });
  *
- *     const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node));
+ *     const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node.key));
  *     console.log(topPlayersEquipments); // [
  *  //      [
  *  //        {
@@ -279,55 +188,229 @@ export declare class TreeMultiMapNode<K = any, V = any> {
  *  //      ]
  *  //    ];
  */
-export declare class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[], R> implements IBinaryTree<K, V[], R> {
+export declare class TreeMultiMap<K = any, V = any, R = any> implements Iterable<[K, V[]]> {
+    #private;
     /**
-     * Create a TreeMultiMap and optionally bulk-insert items.
-     * @remarks Time O(N log N), Space O(N)
-     * @param [keysNodesEntriesOrRaws] - Iterable of keys/nodes/entries/raw items to insert.
-     * @param [options] - Options for TreeMultiMap (comparator, reverse, map mode).
-     * @returns New TreeMultiMap instance.
+     * Creates a new TreeMultiMap.
+     * @param keysNodesEntriesOrRaws - Initial entries
+     * @param options - Configuration options
+     * @remarks Time O(m log m), Space O(m) where m is the number of initial entries
      */
-    constructor(keysNodesEntriesOrRaws?: Iterable<K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | R>, options?: TreeMultiMapOptions<K, V[], R>);
-    createNode(key: K, value?: V[]): TreeMultiMapNode<K, V>;
+    constructor(keysNodesEntriesOrRaws?: Iterable<K | [K | null | undefined, V[] | undefined] | null | undefined | R>, options?: TreeMultiMapOptions<K, V[], R>);
     /**
-     * Checks if the given item is a `TreeMultiMapNode` instance.
+     * Validates the key against the default comparator rules.
      * @remarks Time O(1), Space O(1)
-     *
-     * @param keyNodeOrEntry - The item to check.
-     * @returns True if it's a TreeMultiMapNode, false otherwise.
      */
-    isNode(keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): keyNodeOrEntry is TreeMultiMapNode<K, V>;
-    set(keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
+    private _validateKey;
+    /**
+     * Number of distinct keys.
+     * @remarks Time O(1), Space O(1)
+     */
+    get size(): number;
+    /**
+     * Whether the map is empty.
+     * @remarks Time O(1), Space O(1)
+     */
+    isEmpty(): boolean;
+    /**
+     * Removes all entries from the map.
+     * @remarks Time O(1), Space O(1)
+     */
+    clear(): void;
+    /**
+     * Bucket length for a key (missing => 0).
+     * @remarks Time O(log n), Space O(1)
+     */
+    count(key: K): number;
+    /**
+     * Total number of values across all buckets (Σ bucket.length).
+     * @remarks Time O(n), Space O(1)
+     */
+    get totalSize(): number;
+    /**
+     * Whether the map contains the given key.
+     * @remarks Time O(log n), Space O(1)
+     */
+    has(key: K): boolean;
+    /**
+     * Live bucket reference (do not auto-delete key if bucket becomes empty via mutation).
+     * @remarks Time O(log n), Space O(1)
+     */
+    get(key: K): V[] | undefined;
+    /**
+     * Append a single value.
+     * @remarks Time O(log n), Space O(1)
+     */
+    add(key: K, value: V): boolean;
+    /**
+     * Alias for compatibility with existing TreeMultiMap semantics.
+     * @remarks Time O(log n), Space O(1) for single value; O(log n + m) for bucket append
+     */
+    set(entry: [K | null | undefined, V[] | undefined] | K | null | undefined, value?: V): boolean;
     set(key: K, value: V): boolean;
     /**
-     * Delete a single value from the bucket at a given key. Removes the key if the bucket becomes empty.
-     * @remarks Time O(log N), Space O(1)
-     * @param keyNodeOrEntry - Key, node, or [key, values] entry to locate the bucket.
-     * @param value - Value to remove from the bucket.
-     * @returns True if the value was removed; false if not found.
+     * Deletes a key and its entire bucket.
+     * @remarks Time O(log n), Space O(1)
+     */
+    delete(key: K): boolean;
+    /**
+     * Check if a specific value exists in a key's bucket.
+     * @remarks Time O(log n + m), Space O(1) where m is bucket size
+     */
+    hasEntry(key: K, value: V, eq?: (a: V, b: V) => boolean): boolean;
+    /**
+     * Delete a single occurrence of a value from a key's bucket.
+     * @remarks Time O(log n + m), Space O(1) where m is bucket size
+     */
+    deleteValue(key: K, value: V, eq?: (a: V, b: V) => boolean): boolean;
+    /**
+     * Delete all occurrences of a value from a key's bucket.
+     * @remarks Time O(log n + m), Space O(1) where m is bucket size
+     */
+    deleteValues(key: K, value: V, eq?: (a: V, b: V) => boolean): number;
+    /**
+     * Iterates over all entries as [key, bucket] pairs.
+     * @remarks Time O(n), Space O(1)
+     */
+    [Symbol.iterator](): Iterator<[K, V[]]>;
+    /**
+     * Iterates over all keys.
+     * @remarks Time O(n), Space O(1)
+     */
+    keys(): IterableIterator<K>;
+    /**
+     * Iterates over all buckets.
+     * @remarks Time O(n), Space O(1)
+     */
+    values(): IterableIterator<V[]>;
+    /**
+     * Iterates over all entries for a specific key.
+     * @remarks Time O(log n + m), Space O(1) where m is bucket size
+     */
+    entriesOf(key: K): IterableIterator<[K, V]>;
+    /**
+     * Iterates over all values for a specific key.
+     * @remarks Time O(log n + m), Space O(1) where m is bucket size
+     */
+    valuesOf(key: K): IterableIterator<V>;
+    /**
+     * Iterates over all [key, value] pairs (flattened from buckets).
+     * @remarks Time O(T), Space O(1) where T is totalSize
+     */
+    flatEntries(): IterableIterator<[K, V]>;
+    /**
+     * Returns the entry with the smallest key.
+     * @remarks Time O(log n), Space O(1)
+     * @example
+     * const map = new TreeMultiMap([[1, ['a']], [2, ['b']]]);
+     * map.first();  // [1, ['a']]
+     */
+    first(): [K, V[]] | undefined;
+    /**
+     * Returns the entry with the largest key.
+     * @remarks Time O(log n), Space O(1)
+     * @example
+     * const map = new TreeMultiMap([[1, ['a']], [2, ['b']]]);
+     * map.last();  // [2, ['b']]
+     */
+    last(): [K, V[]] | undefined;
+    /**
+     * Removes and returns the entry with the smallest key.
+     * @remarks Time O(log n), Space O(1)
+     * @example
+     * const map = new TreeMultiMap([[1, ['a']], [2, ['b']]]);
+     * map.pollFirst();  // [1, ['a']]
+     * map.has(1);       // false
      */
-    deleteValue(keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined, value: V): boolean;
-    map<MK = K, MVArr extends unknown[] = V[], MR = any>(callback: EntryCallback<K, V[] | undefined, [MK, MVArr]>, options?: Partial<TreeMultiMapOptions<MK, MVArr, MR>>, thisArg?: unknown): TreeMultiMap<MK, ElemOf<MVArr>, MR>;
-    map<MK = K, MV = V[], MR = any>(callback: EntryCallback<K, V[] | undefined, [MK, MV]>, options?: Partial<TreeMultiMapOptions<MK, MV, MR>>, thisArg?: unknown): RedBlackTree<MK, MV, MR>;
+    pollFirst(): [K, V[]] | undefined;
     /**
-     * (Protected) Create an empty instance of the same concrete class.
+     * Removes and returns the entry with the largest key.
+     * @remarks Time O(log n), Space O(1)
+     * @example
+     * const map = new TreeMultiMap([[1, ['a']], [2, ['b']]]);
+     * map.pollLast();  // [2, ['b']]
+     * map.has(2);      // false
+     */
+    pollLast(): [K, V[]] | undefined;
+    /**
+     * Returns the entry with the smallest key >= given key.
+     * @remarks Time O(log n), Space O(1)
+     * @example
+     * const map = new TreeMultiMap([[10, ['a']], [20, ['b']], [30, ['c']]]);
+     * map.ceiling(15);  // [20, ['b']]
+     * map.ceiling(20);  // [20, ['b']]
+     */
+    ceiling(key: K): [K, V[]] | undefined;
+    /**
+     * Returns the entry with the largest key <= given key.
+     * @remarks Time O(log n), Space O(1)
+     * @example
+     * const map = new TreeMultiMap([[10, ['a']], [20, ['b']], [30, ['c']]]);
+     * map.floor(25);  // [20, ['b']]
+     * map.floor(20);  // [20, ['b']]
+     */
+    floor(key: K): [K, V[]] | undefined;
+    /**
+     * Returns the entry with the smallest key > given key.
+     * @remarks Time O(log n), Space O(1)
+     * @example
+     * const map = new TreeMultiMap([[10, ['a']], [20, ['b']], [30, ['c']]]);
+     * map.higher(10);  // [20, ['b']]
+     * map.higher(15);  // [20, ['b']]
+     */
+    higher(key: K): [K, V[]] | undefined;
+    /**
+     * Returns the entry with the largest key < given key.
+     * @remarks Time O(log n), Space O(1)
+     * @example
+     * const map = new TreeMultiMap([[10, ['a']], [20, ['b']], [30, ['c']]]);
+     * map.lower(20);  // [10, ['a']]
+     * map.lower(15);  // [10, ['a']]
+     */
+    lower(key: K): [K, V[]] | undefined;
+    /**
+     * Prints the internal tree structure (for debugging).
+     * @remarks Time O(n), Space O(n)
+     */
+    print(...args: any[]): void;
+    /**
+     * Executes a callback for each entry.
+     * @remarks Time O(n), Space O(1)
+     */
+    forEach(callback: (value: V[], key: K, map: this) => void): void;
+    /**
+     * Creates a new map with entries that pass the predicate.
+     * @remarks Time O(n), Space O(n)
+     */
+    filter(predicate: (value: V[], key: K, map: this) => boolean): TreeMultiMap<K, V, R>;
+    /**
+     * Creates a new map by transforming each entry.
+     * @remarks Time O(n log n), Space O(n)
+     */
+    map<V2>(mapper: (value: V[], key: K, map: this) => [K, V2[]]): TreeMultiMap<K, V2, R>;
+    /**
+     * Reduces all entries to a single value.
+     * @remarks Time O(n), Space O(1)
+     */
+    reduce<U>(callback: (accumulator: U, value: V[], key: K, map: this) => U, initialValue: U): U;
+    /**
+     * Sets multiple entries at once.
+     * @remarks Time O(m log n), Space O(m) where m is input size
+     */
+    setMany(keysNodesEntriesOrRaws: Iterable<any>): boolean[];
+    /**
+     * Searches for entries within a key range.
+     * @remarks Time O(log n + k), Space O(k) where k is result size
+     */
+    rangeSearch<C extends (node: RedBlackTreeNode<K, V[]>) => any>(range: any, callback?: C, isBalanced?: any): ReturnType<C>[];
+    /**
+     * Creates a shallow clone of this map.
+     * @remarks Time O(n log n), Space O(n)
+     */
+    clone(): TreeMultiMap<K, V, R>;
+    /**
+     * Expose comparator for advanced usage/testing (read-only).
      * @remarks Time O(1), Space O(1)
-     * @template TK
-     * @template TV
-     * @template TR
-     * @param [options] - Optional constructor options for the like-kind instance.
-     * @returns An empty like-kind instance.
-     */
-    protected _createInstance<TK = K, TV = V, TR = R>(options?: Partial<TreeMultiMapOptions<TK, TV, TR>>): this;
-    /**
-     * (Protected) Create a like-kind instance and seed it from an iterable.
-     * @remarks Time O(N log N), Space O(N)
-     * @template TK
-     * @template TV
-     * @template TR
-     * @param iter - Iterable used to seed the new tree.
-     * @param [options] - Options merged with the current snapshot.
-     * @returns A like-kind RedBlackTree built from the iterable.
-     */
-    protected _createLike<TK = K, TV = V, TR = R>(iter?: Iterable<TK | RedBlackTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<TreeMultiMapOptions<TK, TV, TR>>): RedBlackTree<TK, TV, TR>;
+     */
+    get comparator(): Comparator<K>;
 }