directed-graph-typed 1.48.0 → 1.49.0

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

@@ -5,12 +5,12 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BiTreeDeleteResult, BTNCallback, BTNKey, BTNodeExemplar, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, BTNodeExemplar, BTNodeKeyOrNode, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
-export declare class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNodeNested<V>> extends BSTNode<V, N> {
+export declare class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
     color: RBTNColor;
-    constructor(key: BTNKey, value?: V, color?: RBTNColor);
+    constructor(key: K, value?: V, color?: RBTNColor);
 }
 /**
  * 1. Each node is either red or black.
@@ -19,12 +19,12 @@ export declare class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N>
  * 4. Red nodes must have black children.
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
-export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNode<V, RedBlackTreeNodeNested<V>>, TREE extends RedBlackTree<V, N, TREE> = RedBlackTree<V, N, RedBlackTreeNested<V, N>>> extends BST<V, N, TREE> implements IBinaryTree<V, N, TREE> {
+export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, N, TREE> = RedBlackTree<K, V, N, RedBlackTreeNested<K, V, N>>> extends BST<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
     Sentinel: N;
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -32,14 +32,14 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<RBTreeOptions>);
+    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<RBTreeOptions<K>>);
     protected _root: N;
     get root(): N;
     protected _size: number;
     get size(): number;
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
-     * @param {BTNKey} key - The key parameter is the key value associated with the node. It is used to
+     * @param {K} key - The key parameter is the key value associated with the node. It is used to
      * identify and compare nodes in the Red-Black Tree.
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
      * associated with the node. It is of type `V`, which is a generic type that can be replaced with any
@@ -49,7 +49,7 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
      * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
      * value, and color.
      */
-    createNode(key: BTNKey, value?: V, color?: RBTNColor): N;
+    createNode(key: K, value?: V, color?: RBTNColor): N;
     /**
      * The function creates a Red-Black Tree with the specified options and returns it.
      * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
@@ -57,34 +57,47 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
      * class.
      * @returns a new instance of a RedBlackTree object.
      */
-    createTree(options?: RBTreeOptions): TREE;
+    createTree(options?: RBTreeOptions<K>): TREE;
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
-    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
+    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
     /**
-     * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
-     * otherwise it returns undefined.
-     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing an exemplar of a binary tree
-     * node. It can be either a node itself, an entry (key-value pair), a node key, or any other value
-     * that is not a valid exemplar.
-     * @returns a variable `node` which is of type `N | undefined`.
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<V, N>): N | undefined;
+    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
+    /**
+     * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
+     * `exemplarToNode` function. It represents the value associated with the exemplar node. If a value
+     * is provided, it will be used when creating the new node. If no value is provided, the new node
+     * @returns a node of type N or undefined.
+     */
+    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
      */
     /**
-     * The function adds a node to a Red-Black Tree data structure.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
-     * @returns The method `add` returns either an instance of `N` (the node that was added) or
-     * `undefined`.
+     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Space Complexity: O(1)
+     *
+     * The `add` function adds a new node to a binary search tree and performs necessary rotations and
+     * color changes to maintain the red-black tree properties.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
+     * entry.
+     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
+     * being added to the binary search tree.
+     * @returns The method `add` returns either the newly added node (`N`) or `undefined`.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | undefined;
+    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | undefined;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -110,28 +123,15 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
      * Space Complexity: O(1)
      */
     isRealNode(node: N | undefined): node is N;
-    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
+    getNode<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
     getNode<C extends BTNCallback<N, N>>(identifier: N | undefined, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
     getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     *
-     * The function returns the successor of a given node in a red-black tree.
-     * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
-     * @returns the successor of the given RedBlackTreeNode.
-     */
-    getSuccessor(x: N): N | undefined;
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function returns the predecessor of a given node in a red-black tree.

package/dist/data-structures/binary-tree/rb-tree.js

@@ -29,7 +29,7 @@ class RedBlackTree extends bst_1.BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -53,7 +53,7 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
-     * @param {BTNKey} key - The key parameter is the key value associated with the node. It is used to
+     * @param {K} key - The key parameter is the key value associated with the node. It is used to
      * identify and compare nodes in the Red-Black Tree.
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
      * associated with the node. It is of type `V`, which is a generic type that can be replaced with any
@@ -74,11 +74,11 @@ class RedBlackTree extends bst_1.BST {
      * @returns a new instance of a RedBlackTree object.
      */
     createTree(options) {
-        return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
+        return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
     }
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
@@ -86,14 +86,23 @@ class RedBlackTree extends bst_1.BST {
         return exemplar instanceof RedBlackTreeNode;
     }
     /**
-     * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
-     * otherwise it returns undefined.
-     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing an exemplar of a binary tree
-     * node. It can be either a node itself, an entry (key-value pair), a node key, or any other value
-     * that is not a valid exemplar.
-     * @returns a variable `node` which is of type `N | undefined`.
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
-    exemplarToNode(exemplar) {
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof RedBlackTreeNode);
+    }
+    /**
+     * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
+     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
+     * `exemplarToNode` function. It represents the value associated with the exemplar node. If a value
+     * is provided, it will be used when creating the new node. If no value is provided, the new node
+     * @returns a node of type N or undefined.
+     */
+    exemplarToNode(exemplar, value) {
         let node;
         if (exemplar === null || exemplar === undefined) {
             return;
@@ -110,8 +119,8 @@ class RedBlackTree extends bst_1.BST {
                 node = this.createNode(key, value, types_1.RBTNColor.RED);
             }
         }
-        else if (this.isNodeKey(exemplar)) {
-            node = this.createNode(exemplar, undefined, types_1.RBTNColor.RED);
+        else if (this.isNotNodeInstance(exemplar)) {
+            node = this.createNode(exemplar, value, types_1.RBTNColor.RED);
         }
         else {
             return;
@@ -123,13 +132,19 @@ class RedBlackTree extends bst_1.BST {
      * Space Complexity: O(1)
      */
     /**
-     * The function adds a node to a Red-Black Tree data structure.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
-     * @returns The method `add` returns either an instance of `N` (the node that was added) or
-     * `undefined`.
+     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Space Complexity: O(1)
+     *
+     * The `add` function adds a new node to a binary search tree and performs necessary rotations and
+     * color changes to maintain the red-black tree properties.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
+     * entry.
+     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
+     * being added to the binary search tree.
+     * @returns The method `add` returns either the newly added node (`N`) or `undefined`.
      */
-    add(keyOrNodeOrEntry) {
-        const newNode = this.exemplarToNode(keyOrNodeOrEntry);
+    add(keyOrNodeOrEntry, value) {
+        const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
         if (newNode === undefined)
             return;
         newNode.left = this.Sentinel;
@@ -257,7 +272,9 @@ class RedBlackTree extends bst_1.BST {
      * Space Complexity: O(1)
      */
     isRealNode(node) {
-        return node !== this.Sentinel && node !== undefined;
+        if (node === this.Sentinel || node === undefined)
+            return false;
+        return node instanceof RedBlackTreeNode;
     }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
@@ -276,7 +293,7 @@ class RedBlackTree extends bst_1.BST {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
      * function should take a single parameter of type `N` (the type of the nodes in the binary tree) and
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter is the starting point for
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is the starting point for
      * searching for a node in a binary tree. It can be either a key value or a node object. If it is not
      * provided, the search will start from the root of the binary tree.
      * @param iterationType - The `iterationType` parameter is a variable that determines the type of
@@ -292,35 +309,11 @@ class RedBlackTree extends bst_1.BST {
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     *
-     * The function returns the successor of a given node in a red-black tree.
-     * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
-     * @returns the successor of the given RedBlackTreeNode.
-     */
-    getSuccessor(x) {
-        var _a;
-        if (x.right !== this.Sentinel) {
-            return (_a = this.getLeftMost(x.right)) !== null && _a !== void 0 ? _a : undefined;
-        }
-        let y = x.parent;
-        while (y !== this.Sentinel && y !== undefined && x === y.right) {
-            x = y;
-            y = y.parent;
-        }
-        return y;
-    }
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function returns the predecessor of a given node in a red-black tree.
@@ -329,11 +322,11 @@ class RedBlackTree extends bst_1.BST {
      * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
     getPredecessor(x) {
-        if (x.left !== this.Sentinel) {
+        if (this.isRealNode(x.left)) {
             return this.getRightMost(x.left);
         }
         let y = x.parent;
-        while (y !== this.Sentinel && x === y.left) {
+        while (this.isRealNode(y) && x === y.left) {
             x = y;
             y = y.parent;
         }

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

@@ -5,15 +5,15 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNodeKeyOrNode, BTNKey, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import { BiTreeDeleteResult, BTNCallback, IterationType, TreeMultimapNested } from '../../types';
+import type { BSTNodeKeyOrNode, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, BTNodeKeyOrNode, IterationType, TreeMultimapNested } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class TreeMultimapNode<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNodeNested<V>> extends AVLTreeNode<V, N> {
+export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, N> {
     count: number;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
-     * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
+     * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
      * of the binary tree node.
      * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
      * tree node. If no value is provided, it will be `undefined`.
@@ -21,42 +21,52 @@ export declare class TreeMultimapNode<V = any, N extends TreeMultimapNode<V, N>
      * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
-    constructor(key: BTNKey, value?: V, count?: number);
+    constructor(key: K, value?: V, count?: number);
 }
 /**
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNode<V, TreeMultimapNodeNested<V>>, TREE extends TreeMultimap<V, N, TREE> = TreeMultimap<V, N, TreeMultimapNested<V, N>>> extends AVLTree<V, N, TREE> implements IBinaryTree<V, N, TREE> {
-    constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<TreeMultimapOptions>);
+export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>> extends AVLTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
+    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>);
     private _count;
     get count(): number;
     /**
      * The function creates a new BSTNode with the given key, value, and count.
-     * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
+     * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
      * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
-    createNode(key: BTNKey, value?: V, count?: number): N;
-    createTree(options?: TreeMultimapOptions): TREE;
+    createNode(key: K, value?: V, count?: number): N;
+    createTree(options?: TreeMultimapOptions<K>): TREE;
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
-    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
+    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`, where `V` represents
-     * the value type and `N` represents the node type.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it
+     * can be one of the following:
+     * @param {V} [value] - The `value` parameter is an optional argument that represents the value
+     * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
+     * it defaults to `undefined`.
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the node should be created. If not provided, it defaults to 1.
-     * @returns a value of type `N` (the generic type parameter) or `undefined`.
+     * times the value should be added to the node. If not provided, it defaults to 1.
+     * @returns a node of type `N` or `undefined`.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<V, N>, count?: number): N | undefined;
+    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | undefined;
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -65,15 +75,19 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
      *
-     * The `add` function overrides the base class `add` function to add a new node to the tree multimap
-     * and update the count.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
-     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key or node or entry should be added to the multimap. If not provided, the default value
-     * is 1.
-     * @returns either a node (`N`) or `undefined`.
-     */
-    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>, count?: number): N | undefined;
+     * The function overrides the add method of a binary tree node and adds a new node to the tree.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
+     * entry. It represents the key, node, or entry that you want to add to the binary tree.
+     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+     * binary tree node. It is an optional parameter, meaning it can be omitted when calling the `add`
+     * method.
+     * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
+     * be added to the binary tree. By default, it is set to 1, meaning that the key-value pair will be
+     * added once. However, you can specify a different value for `count` if you want to add
+     * @returns The method is returning either the newly inserted node or `undefined` if the insertion
+     * was not successful.
+     */
+    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | undefined;
     /**
      * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -88,7 +102,7 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * either keys, nodes, or entries.
      * @returns The method is returning an array of type `N | undefined`.
      */
-    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<V, N>>): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>): (N | undefined)[];
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
@@ -137,6 +151,18 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear(): void;
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a deep copy of a tree object.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone(): TREE;
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
@@ -146,22 +172,22 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
      * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
      * `undefined` if there is no node to add.
-     * @param {BTNKey | N | undefined} parent - The `parent` parameter represents the parent node to
+     * @param {K | N | undefined} parent - The `parent` parameter represents the parent node to
      * which the new node will be added as a child. It can be either a node object (`N`) or a key value
-     * (`BTNKey`).
+     * (`K`).
      * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
      * added, or `undefined` if no node was added.
      */
-    protected _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<N>): N | undefined;
+    protected _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<K, N>): N | undefined;
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-     * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
-     * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
-     * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
+     * which the values will be swapped. It can be of type `K`, `N`, or `undefined`.
+     * @param {K | N | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    protected _swapProperties(srcNode: BSTNodeKeyOrNode<N>, destNode: BSTNodeKeyOrNode<N>): N | undefined;
+    protected _swapProperties(srcNode: BSTNodeKeyOrNode<K, N>, destNode: BSTNodeKeyOrNode<K, N>): N | undefined;
     protected _replaceNode(oldNode: N, newNode: N): N;
 }