undirected-graph-typed 1.51.8 → 1.51.9

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

@@ -65,18 +65,18 @@ export declare class BinaryTreeNode<K extends Comparable, V = any, NODE extends
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
  */
-export declare class BinaryTree<K extends Comparable, V = any, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, NODE, TREE> = BinaryTree<K, V, NODE, BinaryTreeNested<K, V, NODE>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, NODE, TREE> {
+export declare class BinaryTree<K extends Comparable, V = any, R = BTNEntry<K, V>, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTree<K, V, R, NODE, BinaryTreeNested<K, V, R, NODE>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, R, NODE, TREE> {
     iterationType: IterationType;
     /**
-     * The constructor function initializes a binary tree object with optional keysOrNodesOrEntries and options.
-     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * The constructor function initializes a binary tree object with optional keysOrNodesOrEntriesOrRawElements and options.
+     * @param [keysOrNodesOrEntriesOrRawElements] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
      * nodes to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
      * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
      * required.
      */
-    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: BinaryTreeOptions);
+    constructor(keysOrNodesOrEntriesOrRawElements?: Iterable<R | KeyOrNodeOrEntry<K, V, NODE>>, options?: BinaryTreeOptions<K, V, R>);
     protected _root?: NODE | null;
     /**
      * The function returns the root node, which can be of type NODE, null, or undefined.
@@ -96,6 +96,12 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * @returns The method is returning the value of the `_NIL` property.
      */
     get NIL(): NODE;
+    protected _toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
+    /**
+     * The function returns the value of the _toEntryFn property.
+     * @returns The function being returned is `this._toEntryFn`.
+     */
+    get toEntryFn(): ((rawElement: R) => BTNEntry<K, V>) | undefined;
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {K} key - The key for the new node.
@@ -110,16 +116,19 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * you can provide only a subset of the properties defined in the `BinaryTreeOptions` interface.
      * @returns a new instance of a binary tree.
      */
-    createTree(options?: Partial<BinaryTreeOptions>): TREE;
+    createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): TREE;
     /**
-     * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
+     * The function `keyValueOrEntryOrRawElementToNode` converts a key-value pair, entry, or raw element
+     * into a node object.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If no value
-     * is provided, it will be `undefined`.
-     * @returns a value of type NODE (node), or null, or undefined.
+     * `keyValueOrEntryOrRawElementToNode` function. It represents the value associated with a key in a
+     * key-value pair. If provided, it will be used to create a node with the specified key and value.
+     * @returns The function `keyValueOrEntryOrRawElementToNode` returns either a `NODE` object, `null`,
+     * or `undefined`.
      */
-    keyValueOrEntryToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | null | undefined;
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | null | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -128,49 +137,65 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
      *
-     * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
-     * key, otherwise it returns the key itself.
-     * @param {K | NODE | null | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `NODE`,
-     * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be used when searching for a node by key. It has a default value of
-     * `'ITERATIVE'`.
-     * @returns either the node corresponding to the given key if it is a valid node key, or the key
-     * itself if it is not a valid node key.
-     */
-    ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
-    /**
-     * The function checks if a given node is a real node or null.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * The `ensureNode` function checks if the input is a valid node and returns it, or converts it to a
+     * node if it is a key or entry.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, `KeyOrNodeOrEntry<K, V, NODE>`, or
+     * a raw element.
+     * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
+     * parameter that specifies the type of iteration to be used when searching for a node. It has a
+     * default value of `'ITERATIVE'`.
+     * @returns The function `ensureNode` returns either a `NODE` object, `null`, or `undefined`.
+     */
+    ensureNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    /**
+     * The function checks if the input is an instance of the BinaryTreeNode class.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * an instance of the `BinaryTreeNode` class.
+     */
+    isNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is NODE;
+    /**
+     * The function checks if a given node is a valid node in a binary search tree.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
-    isNodeOrNull(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE | null;
+    isRealNode(node: R | KeyOrNodeOrEntry<K, V, NODE>): node is NODE;
     /**
-     * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the class NODE.
+     * The function checks if a given node is a real node or null.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value.
      */
-    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
+    isNodeOrNull(node: R | KeyOrNodeOrEntry<K, V, NODE>): node is NODE | null;
     /**
-     * The function checks if a given node is a real node by verifying if it is an instance of
-     * BinaryTreeNode and its key is not NaN.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * The function checks if a given node is equal to the NIL value.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
-    isRealNode(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE;
+    isNIL(node: R | KeyOrNodeOrEntry<K, V, NODE>): boolean;
     /**
-     * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * The function checks if the input is an array with two elements, indicating it is a binary tree
+     * node entry.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
-    isNIL(node: KeyOrNodeOrEntry<K, V, NODE>): boolean;
+    isEntry(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is BTNEntry<K, V>;
     /**
-     * The function checks if a given value is an entry in a binary tree node.
-     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
-     * two type parameters V and NODE, representing the value and node type respectively.
+     * The function checks if a given value is a valid key by evaluating its type and value.
+     * @param {any} key - The `key` parameter can be of any type. It is the value that we want to check
+     * if it is a valid key.
+     * @param [isCheckValueOf=true] - The `isCheckValueOf` parameter is a boolean flag that determines
+     * whether the function should check the valueOf() method of an object when the key is of type
+     * 'object'. If `isCheckValueOf` is true, the function will recursively call itself with the value
+     * returned by key.valueOf().
      * @returns a boolean value.
      */
-    isEntry(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is BTNEntry<K, V>;
+    isKey(key: any, isCheckValueOf?: boolean): key is K;
     /**
      * Time Complexity O(n)
      * Space Complexity O(1)
@@ -179,13 +204,19 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity O(n)
      * Space Complexity O(1)
      *
-     * The `add` function adds a new node to a binary tree, either by creating a new node or replacing an
-     * existing node with the same key.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
-     * @param {V} [value] - The value to be inserted into the binary tree.
-     * @returns The function `add` returns either a node (`NODE`), `null`, or `undefined`.
-     */
-    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
+     * The `add` function is used to insert a new node into a binary tree, checking for duplicate keys
+     * and finding the appropriate insertion position.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The
+     * `keyOrNodeOrEntryOrRawElement` parameter can accept a value of type `R`, which represents the key,
+     * node, entry, or raw element to be added to the tree. It can also accept a value of type
+     * `KeyOrNodeOrEntry<K, V, NODE>
+     * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
+     * key being added to the tree. It represents the value that will be stored in the tree for the given
+     * key.
+     * @returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
+     * insertion position cannot be found or if there are duplicate keys.
+     */
+    add(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -195,13 +226,17 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
      *
-     * The `addMany` function takes in a collection of keysOrNodesOrEntries and an optional collection of values, and
-     * adds each node with its corresponding value to the data structure.
-     * @param keysOrNodesOrEntries - An iterable collection of KeyOrNodeOrEntry objects.
-     * @param [values] - An optional iterable of values that will be assigned to each node being added.
-     * @returns The function `addMany` returns an array of `NODE`, `null`, or `undefined` values.
-     */
-    addMany(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
+     * The `addMany` function takes in an iterable of keys or nodes or entries or raw elements, and an
+     * optional iterable of values, and adds each key or node or entry with its corresponding value to a
+     * data structure, returning an array of booleans indicating whether each insertion was successful.
+     * @param keysOrNodesOrEntriesOrRawElements - An iterable containing keys, nodes, entries, or raw
+     * elements. These elements will be added to the data structure.
+     * @param [values] - An optional iterable of values that correspond to the keys or nodes or entries
+     * in the `keysOrNodesOrEntriesOrRawElements` parameter.
+     * @returns The function `addMany` returns an array of booleans indicating whether each element was
+     * successfully added to the data structure.
+     */
+    addMany(keysOrNodesOrEntriesOrRawElements: Iterable<R | KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -211,24 +246,23 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
      *
-     * The `refill` function clears the current data and adds new key-value pairs to the data structure.
-     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries. These can be of type
-     * KeyOrNodeOrEntry<K, V, NODE>.
-     * @param [values] - The `values` parameter is an optional iterable that contains the values to be
-     * associated with the keys or nodes or entries in the `keysOrNodesOrEntries` parameter. If provided,
-     * the values will be associated with the corresponding keys or nodes or entries in the
-     * `keysOrNodesOrEntries` iterable
-     */
-    refill(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): void;
+     * The `refill` function clears the current data and adds new data to the collection.
+     * @param keysOrNodesOrEntriesOrRawElements - An iterable collection of keys, nodes, entries, or raw
+     * elements. These can be of any type (R) or a specific type (KeyOrNodeOrEntry<K, V, NODE>).
+     * @param [values] - The `values` parameter is an optional iterable of values that will be associated
+     * with the keys or nodes being added. If provided, the values will be assigned to the corresponding
+     * keys or nodes. If not provided, the values will be set to `undefined`.
+     */
+    refill(keysOrNodesOrEntriesOrRawElements: Iterable<R | KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): void;
     delete<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C): BinaryTreeDeleteResult<NODE>[];
     delete<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C): BinaryTreeDeleteResult<NODE>[];
     delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C): BinaryTreeDeleteResult<NODE>[];
-    getNodes<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
-    getNodes<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
-    getNodes<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
-    getNode<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
-    getNode<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
-    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    getNodes<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, onlyOne?: boolean, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    getNodes<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    getNodes<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    getNode<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    getNode<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -237,23 +271,21 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
      *
-     * The function `getNodeByKey` searches for a node in a binary tree by its key, using either
-     * recursive or iterative iteration.
-     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
-     * It is used to find the node with the matching key value.
-     * @param iterationType - The `iterationType` parameter is used to determine whether the search for
-     * the node with the given key should be performed iteratively or recursively. It has two possible
-     * values:
-     * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
-     * found in the binary tree. If no node is found, it returns `undefined`.
+     * The function `getNodeByKey` returns a node with a specific key value from a tree structure.
+     * @param {K} key - The key parameter is the value that you want to search for in the tree. It is
+     * used to find the node with the matching key value.
+     * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
+     * parameter that specifies the type of iteration to be used when searching for a node in the tree.
+     * It has a default value of `'ITERATIVE'`.
+     * @returns a value of type NODE, null, or undefined.
      */
     getNodeByKey(key: K, iterationType?: IterationType): NODE | null | undefined;
-    get<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
-    has<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
+    get<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
+    has<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -287,12 +319,13 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      *
      * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
      * height of the tree.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for calculating the height and minimum height of a binary tree. It can be either a `K` (a key
-     * value of a binary tree node), `NODE` (a node of a binary tree), `null`, or `undefined`. If
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The parameter `beginRoot` is optional and
+     * has a default value of `this.root`. It represents the starting point for checking if the tree is
+     * perfectly balanced. It can be either a root node (`R`), a key or node or entry
+     * (`KeyOrNodeOrEntry<K, V, NODE
      * @returns a boolean value.
      */
-    isPerfectlyBalanced(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>): boolean;
+    isPerfectlyBalanced(beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -301,15 +334,17 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function `isSubtreeBST` checks if a given binary tree is a valid binary search tree.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the root
-     * node of the binary search tree (BST) that you want to check if it is a subtree of another BST.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when checking if a subtree is a binary search tree (BST). It can have two
-     * possible values:
+     * The function `isBST` checks if a binary search tree is valid, either recursively or iteratively.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point for checking if a binary search tree (BST) is valid. It can be either a root node
+     * of the BST, a key value of a node in the BST, or an entry object containing both the key and value
+     * of a node in the BST
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to determine the type
+     * of iteration to be performed while checking if the binary search tree (BST) is valid. It can have
+     * two possible values:
      * @returns a boolean value.
      */
-    isBST(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
+    isBST(beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -318,35 +353,35 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The function calculates the depth of a given node in a binary tree.
-     * @param {K | NODE | null | undefined} dist - The `dist` parameter represents the node in
-     * the binary tree whose depth we want to find. It can be of type `K`, `NODE`, `null`, or
-     * `undefined`.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
-     * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
-     * `NODE` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
-     * @returns the depth of the `dist` relative to the `beginRoot`.
-     */
-    getDepth(dist: KeyOrNodeOrEntry<K, V, NODE>, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>): number;
+     * The function calculates the depth of a given node or key in a tree-like data structure.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} dist - The `dist` parameter can be either a `R`
+     * (representing a root node), or a `KeyOrNodeOrEntry<K, V, NODE>` (representing a key, node, or
+     * entry).
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is optional and
+     * represents the starting point from which to calculate the depth. It can be either a reference to a
+     * node in the tree or a key-value pair or an entry object. If not provided, the default value is
+     * `this.root`, which refers to the root node
+     * @returns the depth of a node in a tree structure.
+     */
+    getDepth(dist: R | KeyOrNodeOrEntry<K, V, NODE>, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Space Complexity: O(1)
      *
-     * The function `getHeight` calculates the maximum height of a binary tree using either recursive or
-     * iterative traversal.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node of the binary tree from which we want to calculate the height. It can be of type
-     * `K`, `NODE`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
-     * @param iterationType - The `iterationType` parameter is used to determine whether to calculate the
-     * height of the tree using a recursive approach or an iterative approach. It can have two possible
-     * values:
-     * @returns the height of the binary tree.
+     * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
+     * or iterative approach.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point for calculating the height of a tree. It can be either a root node (`R`), a key or
+     * node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current tree.
+     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
+     * iteration used to calculate the height of the tree. It can have two possible values:
+     * @returns the maximum height of the binary tree.
      */
-    getHeight(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
+    getHeight(beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -357,34 +392,35 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node of the binary tree from which we want to calculate the minimum height. It can be of
-     * type `K`, `NODE`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
-     * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
-     * to calculate the minimum height of a binary tree. It can have two possible values:
-     * @returns The function `getMinHeight` returns the minimum height of a binary tree.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point for calculating the minimum height of a tree. It can be either a root node (`R`), a
+     * key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or it defaults to the root of the current
+     * tree.
+     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
+     * iteration to be used when calculating the minimum height of the tree. It can have two possible
+     * values:
+     * @returns The function `getMinHeight` returns a number, which represents the minimum height of the
+     * binary tree.
      */
-    getMinHeight(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
+    getMinHeight(beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
-     * /
-  
-     /**
+     */
+    /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
-     * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
-     * structure, with the option to reverse the order of the nodes.
-     * @param {K | NODE | null | undefined} beginNode - The `beginRoot` parameter represents the
-     * starting node from which you want to find the path to the root. It can be of type `K`, `NODE`,
-     * `null`, or `undefined`.
+     * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
+     * up to the root node, with an option to reverse the order of the nodes.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginNode - The `beginNode` parameter can be either of
+     * type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
      * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
      * resulting path should be reversed or not. If `isReverse` is set to `true`, the path will be
-     * reversed before returning it. If `isReverse` is set to `false`, the path will be returned as is
-     * @returns The function `getPathToRoot` returns an array of nodes (`NODE[]`).
+     * reversed before returning it. If `isReverse` is set to `false` or not provided, the path will
+     * @returns The function `getPathToRoot` returns an array of `NODE` objects.
      */
-    getPathToRoot(beginNode: KeyOrNodeOrEntry<K, V, NODE>, isReverse?: boolean): NODE[];
+    getPathToRoot(beginNode: R | KeyOrNodeOrEntry<K, V, NODE>, isReverse?: boolean): NODE[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -393,17 +429,16 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `getLeftMost` returns the leftmost node in a binary tree, either recursively or
-     * iteratively.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for finding the leftmost node in a binary tree. It can be either a `K` (a key value), `NODE` (a
-     * node), `null`, or `undefined`. If not provided, it defaults to `this.root`,
-     * @param iterationType - The `iterationType` parameter is used to determine the type of iteration to
-     * be performed when finding the leftmost node in a binary tree. It can have two possible values:
-     * @returns The function `getLeftMost` returns the leftmost node (`NODE`) in the binary tree. If there
-     * is no leftmost node, it returns `null` or `undefined` depending on the input.
+     * The `getLeftMost` function returns the leftmost node in a binary tree, either using recursive or
+     * iterative traversal.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point for finding the leftmost node in a binary tree. It can be either a root node (`R`),
+     * a key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
+     * of iteration to be performed. It can have two possible values:
+     * @returns The function `getLeftMost` returns the leftmost node in a binary tree.
      */
-    getLeftMost(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    getLeftMost(beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -412,18 +447,17 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `getRightMost` returns the rightmost node in a binary tree, either recursively or
+     * The `getRightMost` function returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node from which we want to find the rightmost node. It can be of type `K`, `NODE`,
-     * `null`, or `undefined`. If not provided, it defaults to `this.root`, which is a property of the
-     * current object.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when finding the rightmost node. It can have one of two values:
-     * @returns The function `getRightMost` returns the rightmost node (`NODE`) in a binary tree. If there
-     * is no rightmost node, it returns `null` or `undefined`, depending on the input.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * starting point for finding the rightmost node in a binary tree. It can be either a root node
+     * (`R`), a key or node or entry (`KeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
+     * of iteration to be performed when finding the rightmost node in a binary tree. It can have two
+     * possible values:
+     * @returns The function `getRightMost` returns a NODE object, `null`, or `undefined`.
      */
-    getRightMost(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    getRightMost(beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -432,10 +466,10 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function returns the predecessor of a given node in a tree.
-     * @param {NODE} node - The parameter `node` is of type `RedBlackTreeNode`, which represents a node in a
+     * The function returns the predecessor node of a given node in a binary tree.
+     * @param {NODE} node - The parameter "node" is of type "NODE", which represents a node in a binary
      * tree.
-     * @returns the predecessor of the given 'node'.
+     * @returns the predecessor node of the given node.
      */
     getPredecessor(node: NODE): NODE;
     /**
@@ -448,16 +482,16 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      *
      * The function `getSuccessor` returns the next node in a binary tree given a current node.
      * @param {K | NODE | null} [x] - The parameter `x` can be of type `K`, `NODE`, or `null`.
-     * @returns the successor of the given node or key. The successor is the node that comes immediately
-     * after the given node in the inorder traversal of the binary tree.
+     * @returns The function `getSuccessor` returns a `NODE` object if a successor exists, `null` if
+     * there is no successor, and `undefined` if the input `x` is not a valid node.
      */
     getSuccessor(x?: K | NODE | null): NODE | null | undefined;
-    dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    dfs<C extends BTNCallback<NODE | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    bfs<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    bfs<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    listLevels<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    dfs<C extends BTNCallback<NODE | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    bfs<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    bfs<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    listLevels<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -469,19 +503,19 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * The `morris` function performs a depth-first traversal on a binary tree using the Morris traversal
      * algorithm.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It takes a single parameter of type `NODE` (the type of the nodes in the tree) and returns
-     * a value of any type.
-     * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
-     * determines the order in which the nodes of a binary tree are traversed. It can have one of the
+     * the tree. It takes a single argument, which is the current node, and can return any value. The
+     * return type of the `callback` function is determined by the `ReturnType<C>` type, which represents
+     * the return
+     * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `morris` function is used
+     * to specify the order in which the nodes of a binary tree are traversed. It can take one of the
      * following values:
-     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
-     * for the traversal. It can be specified as a key, a node object, or `null`/`undefined` to indicate
-     * the root of the tree. If no value is provided, the default value is the root of the tree.
-     * @returns The function `morris` returns an array of values that are the result of invoking the
-     * `callback` function on each node in the binary tree. The type of the array nodes is determined
-     * by the return type of the `callback` function.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for the traversal. It can be either a node object, a key, or an entry object. If no value is
+     * provided, the `root` of the tree is used as the starting point.
+     * @returns The function `morris` returns an array of values that are the return values of the
+     * callback function `callback`.
      */
-    morris<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>): ReturnType<C>[];
+    morris<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -490,8 +524,7 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
-     * The `clone` function creates a new tree object and copies all the nodes from the original tree to
-     * the new tree.
+     * 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;
@@ -503,16 +536,16 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function creates a new tree by iterating over the nodes of the current tree and
-     * adding only the nodes that satisfy the given predicate function.
-     * @param predicate - The `predicate` parameter is a function that takes three arguments: `value`,
-     * `key`, and `index`. It should return a boolean value indicating whether the pair should be
-     * included in the filtered tree or not.
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
-     * it will be passed as the first argument to the `predicate` function. If `thisArg` is
-     * @returns The `filter` method is returning a new tree object that contains the key-value pairs that
-     * pass the given predicate function.
+     * The `filter` function creates a new tree with entries that pass a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that is used to test each
+     * element in the tree. It takes three arguments: `value`, `key`, and `index`. The `value` argument
+     * represents the value of the current element being processed, the `key` argument represents the key
+     * of the
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. When the `predicate` function is
+     * called, `thisArg` will be used as the value of `this` within the function. If `thisArg`
+     * @returns The `filter` method is returning a new tree object that contains the entries that pass
+     * the given predicate function.
      */
     filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: any): TREE;
     /**
@@ -523,15 +556,15 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function creates a new tree by applying a callback function to each key-value pair in
-     * the original tree.
-     * @param callback - The callback parameter is a function that will be called for each key-value pair
-     * in the tree. It takes four arguments: the value of the current pair, the key of the current pair,
-     * the index of the current pair, and a reference to the tree itself. The callback function should
-     * return a new
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-     * specify the value of `this` within the callback function. If you pass a value for `thisArg`, it
-     * will be used as the `this` value when the callback function is called. If you don't pass a value
+     * The `map` function creates a new tree by applying a callback function to each entry in the current
+     * tree.
+     * @param callback - The callback parameter is a function that will be called for each entry in the
+     * tree. It takes three arguments: value, key, and index. The value argument represents the value of
+     * the current entry, the key argument represents the key of the current entry, and the index
+     * argument represents the index of the
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
      * @returns The `map` method is returning a new tree object.
      */
     map(callback: EntryCallback<K, V | undefined, V>, thisArg?: any): TREE;
@@ -543,24 +576,40 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {K | NODE | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | NODE | null |
-     * undefined`. It represents the root node of a binary tree. The root node can have one of the
-     * following types:
-     * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
-     */
-    print(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, options?: BinaryTreePrintOptions): void;
-    /**
-     * The function `_getIterator` is a protected generator function that returns an iterator for the
-     * key-value pairs in a binary search tree.
-     * @param node - The `node` parameter represents the current node in the binary search tree. It is an
-     * optional parameter with a default value of `this.root`, which means if no node is provided, the
-     * root node of the tree will be used as the starting point for iteration.
-     * @returns The function `_getIterator` returns an `IterableIterator` of key-value pairs `[K, V |
-     * undefined]`.
+     * The `print` function in TypeScript prints the binary tree structure with customizable options.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * point for printing the binary tree. It can be either a node of the binary tree or a key or entry
+     * that exists in the binary tree. If no value is provided, the root of the binary tree will be used
+     * as the starting point.
+     * @param {BinaryTreePrintOptions} [options] - The `options` parameter is an optional object that
+     * allows you to customize the printing behavior. It has the following properties:
+     * @returns Nothing is being returned. The function has a return type of `void`, which means it does
+     * not return any value.
+     */
+    print(beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, options?: BinaryTreePrintOptions): void;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `_getIterator` is a generator function that returns an iterator for the key-value
+     * pairs in a binary search tree.
+     * @param node - The `node` parameter represents the current node in the binary search tree. It is
+     * initially set to the root node of the tree.
+     * @returns an IterableIterator<[K, V | undefined]>.
      */
     protected _getIterator(node?: NODE | null | undefined): IterableIterator<[K, V | undefined]>;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The `_displayAux` function is responsible for generating the display layout of a binary tree node,
      * taking into account various options such as whether to show null, undefined, or NaN nodes.
      * @param {NODE | null | undefined} node - The `node` parameter represents a node in a binary tree.
@@ -577,27 +626,70 @@ export declare class BinaryTree<K extends Comparable, V = any, NODE extends Bina
     protected _displayAux(node: NODE | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
     protected _DEFAULT_CALLBACK: (node: NODE | null | undefined) => K | undefined;
     /**
-     * Swap the data of two nodes in the binary tree.
-     * @param {NODE} srcNode - The source node to swap.
-     * @param {NODE} destNode - The destination node to swap.
-     * @returns {NODE} - The destination node after the swap.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
-    protected _swapProperties(srcNode: KeyOrNodeOrEntry<K, V, NODE>, destNode: KeyOrNodeOrEntry<K, V, NODE>): NODE | undefined;
     /**
-     * The function replaces an old node with a new node in a binary tree.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `_swapProperties` swaps the key-value properties between two nodes.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} srcNode - The source node that will be swapped with the
+     * destination node. It can be either an instance of the class `R`, or an object of type
+     * `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} destNode - The `destNode` parameter is the node where
+     * the properties will be swapped with the `srcNode`.
+     * @returns either the `destNode` object with its properties swapped with the `srcNode` object's
+     * properties, or `undefined` if either `srcNode` or `destNode` is falsy.
+     */
+    protected _swapProperties(srcNode: R | KeyOrNodeOrEntry<K, V, NODE>, destNode: R | KeyOrNodeOrEntry<K, V, NODE>): NODE | undefined;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function replaces a node in a binary tree with a new node, updating the parent, left child,
+     * right child, and root if necessary.
      * @param {NODE} oldNode - The oldNode parameter represents the node that needs to be replaced in the
      * tree.
      * @param {NODE} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
      * tree.
-     * @returns The method is returning the newNode.
+     * @returns the newNode.
      */
     protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
     /**
-     * The function sets the root property of an object to a given value, and if the value is not null,
-     * it also sets the parent property of the value to undefined.
-     * @param {NODE | null | undefined} v - The parameter `v` is of type `NODE | null | undefined`, which means it can either be of
-     * type `NODE` or `null`.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function sets the root property of an object to the provided value, and also updates the
+     * parent property of the new root.
+     * @param {NODE | null | undefined} v - The parameter `v` is of type `NODE | null | undefined`. This
+     * means that it can accept a value of type `NODE`, `null`, or `undefined`.
      */
     protected _setRoot(v: NODE | null | undefined): void;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `_ensureCallback` ensures that a callback function is provided and returns it.
+     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is of type
+     * `ReturnType<C> | null | undefined`. This means it can accept a value that is the return type of
+     * the generic type `C`, or it can be `null` or `undefined`.
+     * @param {C} callback - The `callback` parameter is a function that takes a `node` as an argument
+     * and returns a value. It is of type `C`, which is a generic type that extends the
+     * `BTNCallback<NODE>` type.
+     * @returns the callback parameter.
+     */
     protected _ensureCallback<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback?: C): C;
 }