avl-tree-typed 1.52.0 → 1.52.2

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNCallback, BTNEntry, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, KeyOrNodeOrEntry, NodeDisplayLayout } from '../../types';
+import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNCallback, BTNEntry, BTNKeyOrNodeOrEntry, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeDisplayLayout, OptBTNOrNull } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { IterableEntryBase } from '../base';
 /**
@@ -32,26 +32,26 @@ export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNod
      * @returns The left node of the current node is being returned. It can be either a NODE object,
      * null, or undefined.
      */
-    get left(): NODE | null | undefined;
+    get left(): OptBTNOrNull<NODE>;
     /**
      * The function sets the left child of a node and updates its parent reference.
-     * @param {NODE | null | undefined} v - The parameter `v` can be of type `NODE`, `null`, or
+     * @param {OptBTNOrNull<NODE>} v - The parameter `v` can be of type `NODE`, `null`, or
      * `undefined`.
      */
-    set left(v: NODE | null | undefined);
+    set left(v: OptBTNOrNull<NODE>);
     protected _right?: NODE | null;
     /**
      * The function returns the right node of a binary tree or null if it doesn't exist.
      * @returns The method is returning the value of the `_right` property, which can be a `NODE` object,
      * `null`, or `undefined`.
      */
-    get right(): NODE | null | undefined;
+    get right(): OptBTNOrNull<NODE>;
     /**
      * The function sets the right child of a node and updates its parent.
-     * @param {NODE | null | undefined} v - The parameter `v` can be of type `NODE`, `null`, or
+     * @param {OptBTNOrNull<NODE>} v - The parameter `v` can be of type `NODE`, `null`, or
      * `undefined`.
      */
-    set right(v: NODE | null | undefined);
+    set right(v: OptBTNOrNull<NODE>);
     /**
      * Get the position of the node within its family.
      * @returns {FamilyPosition} - The family position of the node.
@@ -69,21 +69,21 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
     iterationType: IterationType;
     /**
      * The constructor function initializes a binary tree object with optional keysOrNodesOrEntriesOrRawElements and options.
-     * @param [keysOrNodesOrEntriesOrRawElements] - Optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * @param [keysOrNodesOrEntriesOrRawElements] - Optional iterable of BTNKeyOrNodeOrEntry 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(keysOrNodesOrEntriesOrRawElements?: Iterable<R | KeyOrNodeOrEntry<K, V, NODE>>, options?: BinaryTreeOptions<K, V, R>);
-    protected _root?: NODE | null;
+    constructor(keysOrNodesOrEntriesOrRawElements?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: BinaryTreeOptions<K, V, R>);
+    protected _root?: OptBTNOrNull<NODE>;
     /**
      * The function returns the root node, which can be of type NODE, null, or undefined.
      * @returns The method is returning the value of the `_root` property, which can be of type `NODE`,
      * `null`, or `undefined`.
      */
-    get root(): NODE | null | undefined;
+    get root(): OptBTNOrNull<NODE>;
     protected _size: number;
     /**
      * The function returns the size of an object.
@@ -120,15 +120,15 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
     /**
      * 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 {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `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`.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | null | undefined;
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): OptBTNOrNull<NODE>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -139,52 +139,52 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * 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
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, `BTNKeyOrNodeOrEntry<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;
+    ensureNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBTNOrNull<NODE>;
     /**
      * 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>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<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;
+    isNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<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>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
-    isRealNode(node: R | KeyOrNodeOrEntry<K, V, NODE>): node is NODE;
+    isRealNode(node: R | BTNKeyOrNodeOrEntry<K, V, NODE>): node is 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>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
-    isNodeOrNull(node: R | KeyOrNodeOrEntry<K, V, NODE>): node is NODE | null;
+    isNodeOrNull(node: R | BTNKeyOrNodeOrEntry<K, V, NODE>): node is NODE | null;
     /**
      * 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>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
-    isNIL(node: R | KeyOrNodeOrEntry<K, V, NODE>): boolean;
+    isNIL(node: R | BTNKeyOrNodeOrEntry<K, V, NODE>): boolean;
     /**
      * 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>`.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
-    isEntry(keyOrNodeOrEntryOrRawElement: R | KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is BTNEntry<K, V>;
+    isEntry(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is BTNEntry<K, V>;
     /**
      * 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
@@ -206,17 +206,17 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * 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
+     * @param {R | BTNKeyOrNodeOrEntry<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>
+     * `BTNKeyOrNodeOrEntry<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;
+    add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -236,7 +236,7 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @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[];
+    addMany(keysOrNodesOrEntriesOrRawElements: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -248,21 +248,21 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * 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>).
+     * elements. These can be of any type (R) or a specific type (BTNKeyOrNodeOrEntry<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;
+    refill(keysOrNodesOrEntriesOrRawElements: Iterable<R | BTNKeyOrNodeOrEntry<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, NODE>>(identifier: OptBTNOrNull<NODE>, 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?: 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;
+    getNodes<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, onlyOne?: boolean, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    getNodes<C extends BTNCallback<NODE, NODE>>(identifier: OptBTNOrNull<NODE>, callback?: C, onlyOne?: boolean, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    getNodes<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    getNode<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBTNOrNull<NODE>;
+    getNode<C extends BTNCallback<NODE, NODE>>(identifier: OptBTNOrNull<NODE>, callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBTNOrNull<NODE>;
+    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBTNOrNull<NODE>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -279,13 +279,13 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * 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?: 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;
+    getNodeByKey(key: K, iterationType?: IterationType): OptBTNOrNull<NODE>;
+    get<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<NODE, NODE>>(identifier: OptBTNOrNull<NODE>, callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
+    has<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<NODE, NODE>>(identifier: OptBTNOrNull<NODE>, callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -319,13 +319,13 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
      * height of the tree.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The parameter `beginRoot` is optional and
+     * @param {R | BTNKeyOrNodeOrEntry<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
+     * (`BTNKeyOrNodeOrEntry<K, V, NODE
      * @returns a boolean value.
      */
-    isPerfectlyBalanced(beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>): boolean;
+    isPerfectlyBalanced(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -335,7 +335,7 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * Space Complexity: O(1)
      *
      * 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
+     * @param {R | BTNKeyOrNodeOrEntry<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
@@ -344,7 +344,7 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * two possible values:
      * @returns a boolean value.
      */
-    isBST(beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
+    isBST(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -354,16 +354,16 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * Space Complexity: O(1)
      *
      * 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
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} dist - The `dist` parameter can be either a `R`
+     * (representing a root node), or a `BTNKeyOrNodeOrEntry<K, V, NODE>` (representing a key, node, or
      * entry).
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is optional and
+     * @param {R | BTNKeyOrNodeOrEntry<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;
+    getDepth(dist: R | BTNKeyOrNodeOrEntry<K, V, NODE>, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -374,14 +374,14 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * 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
+     * @param {R | BTNKeyOrNodeOrEntry<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.
+     * node or entry (`BTNKeyOrNodeOrEntry<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?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
+    getHeight(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -392,9 +392,9 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<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
+     * key or node or entry (`BTNKeyOrNodeOrEntry<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
@@ -402,7 +402,7 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns The function `getMinHeight` returns a number, which represents the minimum height of the
      * binary tree.
      */
-    getMinHeight(beginRoot?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
+    getMinHeight(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -413,14 +413,14 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * 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 {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginNode - The `beginNode` parameter can be either of
+     * type `R` or `BTNKeyOrNodeOrEntry<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` or not provided, the path will
      * @returns The function `getPathToRoot` returns an array of `NODE` objects.
      */
-    getPathToRoot(beginNode: R | KeyOrNodeOrEntry<K, V, NODE>, isReverse?: boolean): NODE[];
+    getPathToRoot(beginNode: R | BTNKeyOrNodeOrEntry<K, V, NODE>, isReverse?: boolean): NODE[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -431,14 +431,14 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * 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
+     * @param {R | BTNKeyOrNodeOrEntry<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`.
+     * a key or node or entry (`BTNKeyOrNodeOrEntry<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?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    getLeftMost(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBTNOrNull<NODE>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -449,15 +449,15 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * The `getRightMost` function returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
+     * @param {R | BTNKeyOrNodeOrEntry<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`.
+     * (`R`), a key or node or entry (`BTNKeyOrNodeOrEntry<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?: R | KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    getRightMost(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBTNOrNull<NODE>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -485,13 +485,13 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @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?: 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>[][];
+    getSuccessor(x?: K | NODE | null): OptBTNOrNull<NODE>;
+    dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    dfs<C extends BTNCallback<NODE | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    bfs<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    bfs<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    listLevels<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -509,13 +509,13 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @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 {R | KeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {R | BTNKeyOrNodeOrEntry<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?: R | KeyOrNodeOrEntry<K, V, NODE>): ReturnType<C>[];
+    morris<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -577,7 +577,7 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * Space Complexity: O(n)
      *
      * 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
+     * @param {R | BTNKeyOrNodeOrEntry<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.
@@ -586,7 +586,7 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @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;
+    print(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, options?: BinaryTreePrintOptions): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -601,7 +601,7 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * 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]>;
+    protected _getIterator(node?: OptBTNOrNull<NODE>): IterableIterator<[K, V | undefined]>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -612,7 +612,7 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * 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.
+     * @param {OptBTNOrNull<NODE>} node - The `node` parameter represents a node in a binary tree.
      * It can be of type `NODE`, `null`, or `undefined`.
      * @param {BinaryTreePrintOptions} options - The `options` parameter is an object that contains the
      * following properties:
@@ -623,8 +623,8 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * 3. `totalHeight`: The total height of the node display.
      * 4. `middleIndex`: The index of the middle character
      */
-    protected _displayAux(node: NODE | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
-    protected _DEFAULT_CALLBACK: (node: NODE | null | undefined) => K | undefined;
+    protected _displayAux(node: OptBTNOrNull<NODE>, options: BinaryTreePrintOptions): NodeDisplayLayout;
+    protected _DEFAULT_CALLBACK: (node: OptBTNOrNull<NODE>) => K | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -634,15 +634,15 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * 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
+     * @param {R | BTNKeyOrNodeOrEntry<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
+     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {R | BTNKeyOrNodeOrEntry<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;
+    protected _swapProperties(srcNode: R | BTNKeyOrNodeOrEntry<K, V, NODE>, destNode: R | BTNKeyOrNodeOrEntry<K, V, NODE>): NODE | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -670,10 +670,10 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      *
      * 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
+     * @param {OptBTNOrNull<NODE>} v - The parameter `v` is of type `OptBTNOrNull<NODE>`. This
      * means that it can accept a value of type `NODE`, `null`, or `undefined`.
      */
-    protected _setRoot(v: NODE | null | undefined): void;
+    protected _setRoot(v: OptBTNOrNull<NODE>): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)