linked-list-typed 1.50.2 → 1.50.4

package/dist/data-structures/base/iterable-base.d.ts

@@ -198,7 +198,10 @@ export declare abstract class IterableEntryBase<K = any, V = any> {
      */
     print(): void;
     abstract isEmpty(): boolean;
+    abstract clear(): void;
     abstract clone(): any;
+    abstract map(...args: any[]): any;
+    abstract filter(...args: any[]): any;
     protected abstract _getIterator(...args: any[]): IterableIterator<[K, V]>;
 }
 export declare abstract class IterableElementBase<E = any, C = any> {
@@ -343,6 +346,9 @@ export declare abstract class IterableElementBase<E = any, C = any> {
      */
     print(): void;
     abstract isEmpty(): boolean;
+    abstract clear(): void;
     abstract clone(): C;
+    abstract map(...args: any[]): any;
+    abstract filter(...args: any[]): any;
     protected abstract _getIterator(...args: any[]): IterableIterator<E>;
 }

package/dist/data-structures/binary-tree/{tree-multimap.d.ts → avl-tree-multi-map.d.ts}

@@ -5,12 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, TreeMultimapNested, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
+import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry } from '../../types';
 import { IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class TreeMultimapNode<K = any, V = any, NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
-    count: number;
+export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -22,13 +21,30 @@ export declare class TreeMultimapNode<K = any, V = any, NODE extends TreeMultima
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
     constructor(key: K, value?: V, count?: number);
+    protected _count: number;
+    /**
+     * The function returns the value of the protected variable _count.
+     * @returns The count property of the object, which is of type number.
+     */
+    get count(): number;
+    /**
+     * The above function sets the value of the count property.
+     * @param {number} value - The value parameter is of type number, which means it can accept any
+     * numeric value.
+     */
+    set count(value: number);
 }
 /**
- * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * The only distinction between a AVLTreeMultiMap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultimap<K = any, V = any, NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, NODE, TREE> = TreeMultimap<K, V, NODE, TreeMultimapNested<K, V, NODE>>> extends AVLTree<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
-    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: TreeMultimapOptions<K>);
-    private _count;
+export declare class AVLTreeMultiMap<K = any, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>, TREE extends AVLTreeMultiMap<K, V, NODE, TREE> = AVLTreeMultiMap<K, V, NODE, AVLTreeMultiMapNested<K, V, NODE>>> extends AVLTree<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: AVLTreeMultiMapOptions<K>);
+    protected _count: number;
+    /**
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
     get count(): number;
     /**
      * The function creates a new BSTNode with the given key, value, and count.
@@ -40,7 +56,16 @@ export declare class TreeMultimap<K = any, V = any, NODE extends TreeMultimapNod
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
     createNode(key: K, value?: V, count?: number): NODE;
-    createTree(options?: TreeMultimapOptions<K>): TREE;
+    /**
+     * The function creates a new AVLTreeMultiMap object with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `AVLTreeMultiMap` object. It can include properties such as
+     * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
+     * the tree, respectively. These properties can be
+     * @returns a new instance of the `AVLTreeMultiMap` class, with the provided options merged with the
+     * default options. The returned value is casted as `TREE`.
+     */
+    createTree(options?: AVLTreeMultiMapOptions<K>): TREE;
     /**
      * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, which means it
@@ -54,9 +79,9 @@ export declare class TreeMultimap<K = any, V = any, NODE extends TreeMultimapNod
      */
     keyValueOrEntryToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): NODE | undefined;
     /**
-     * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+     * The function checks if an keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode class.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode
      * class.
      */
     isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
@@ -154,5 +179,13 @@ export declare class TreeMultimap<K = any, V = any, NODE extends TreeMultimapNod
      * if either `srcNode` or `destNode` is undefined.
      */
     protected _swapProperties(srcNode: BSTNKeyOrNode<K, NODE>, destNode: BSTNKeyOrNode<K, NODE>): NODE | undefined;
+    /**
+     * The function replaces an old node with a new node and updates the count property of the new node.
+     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+     * needs to be replaced in a data structure.
+     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, after updating the `count` property of the `newNode` object.
+     */
     protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
 }

package/dist/data-structures/binary-tree/{tree-multimap.js → avl-tree-multi-map.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeMultimap = exports.TreeMultimapNode = void 0;
+exports.AVLTreeMultiMap = exports.AVLTreeMultiMapNode = void 0;
 const types_1 = require("../../types");
 const avl_tree_1 = require("./avl-tree");
-class TreeMultimapNode extends avl_tree_1.AVLTreeNode {
+class AVLTreeMultiMapNode extends avl_tree_1.AVLTreeNode {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -16,14 +16,30 @@ class TreeMultimapNode extends avl_tree_1.AVLTreeNode {
      */
     constructor(key, value, count = 1) {
         super(key, value);
+        this._count = 1;
         this.count = count;
     }
+    /**
+     * The function returns the value of the protected variable _count.
+     * @returns The count property of the object, which is of type number.
+     */
+    get count() {
+        return this._count;
+    }
+    /**
+     * The above function sets the value of the count property.
+     * @param {number} value - The value parameter is of type number, which means it can accept any
+     * numeric value.
+     */
+    set count(value) {
+        this._count = value;
+    }
 }
-exports.TreeMultimapNode = TreeMultimapNode;
+exports.AVLTreeMultiMapNode = AVLTreeMultiMapNode;
 /**
- * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * The only distinction between a AVLTreeMultiMap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-class TreeMultimap extends avl_tree_1.AVLTree {
+class AVLTreeMultiMap extends avl_tree_1.AVLTree {
     constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
         this._count = 0;
@@ -31,6 +47,11 @@ class TreeMultimap extends avl_tree_1.AVLTree {
             this.addMany(keysOrNodesOrEntries);
     }
     // TODO the _count is not accurate after nodes count modified
+    /**
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
     get count() {
         let sum = 0;
         this.dfs(node => (sum += node.count));
@@ -46,10 +67,19 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
     createNode(key, value, count) {
-        return new TreeMultimapNode(key, value, count);
+        return new AVLTreeMultiMapNode(key, value, count);
     }
+    /**
+     * The function creates a new AVLTreeMultiMap object with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `AVLTreeMultiMap` object. It can include properties such as
+     * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
+     * the tree, respectively. These properties can be
+     * @returns a new instance of the `AVLTreeMultiMap` class, with the provided options merged with the
+     * default options. The returned value is casted as `TREE`.
+     */
     createTree(options) {
-        return new TreeMultimap([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
+        return new AVLTreeMultiMap([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
     }
     /**
      * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
@@ -88,13 +118,13 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return node;
     }
     /**
-     * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+     * The function checks if an keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode class.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode
      * class.
      */
     isNode(keyOrNodeOrEntry) {
-        return keyOrNodeOrEntry instanceof TreeMultimapNode;
+        return keyOrNodeOrEntry instanceof AVLTreeMultiMapNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -319,9 +349,17 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         }
         return undefined;
     }
+    /**
+     * The function replaces an old node with a new node and updates the count property of the new node.
+     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+     * needs to be replaced in a data structure.
+     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, after updating the `count` property of the `newNode` object.
+     */
     _replaceNode(oldNode, newNode) {
         newNode.count = oldNode.count + newNode.count;
         return super._replaceNode(oldNode, newNode);
     }
 }
-exports.TreeMultimap = TreeMultimap;
+exports.AVLTreeMultiMap = AVLTreeMultiMap;

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

@@ -9,8 +9,27 @@ import { BST, BSTNode } from './bst';
 import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 export declare class AVLTreeNode<K = any, V = any, NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
-    height: number;
+    /**
+     * The constructor function initializes a new instance of a class with a key and an optional value,
+     * and sets the height property to 0.
+     * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
+     * constructor. It is used to initialize the key property of the object being created.
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
+     * value associated with the key in the constructor.
+     */
     constructor(key: K, value?: V);
+    protected _height: number;
+    /**
+     * The function returns the value of the height property.
+     * @returns The height of the object.
+     */
+    get height(): number;
+    /**
+     * The above function sets the value of the height property.
+     * @param {number} value - The value parameter is a number that represents the new height value to be
+     * set.
+     */
+    set height(value: number);
 }
 /**
  * 1. Height-Balanced: Each node's left and right subtrees differ in height by no more than one.
@@ -195,5 +214,14 @@ export declare class AVLTree<K = any, V = any, NODE extends AVLTreeNode<K, V, NO
      * AVL tree that needs to be balanced.
      */
     protected _balancePath(node: KeyOrNodeOrEntry<K, V, NODE>): void;
+    /**
+     * The function replaces an old node with a new node while preserving the height of the old node.
+     * @param {NODE} oldNode - The `oldNode` parameter is the node that you want to replace with the
+     * `newNode`.
+     * @param {NODE} newNode - The `newNode` parameter is the new node that will replace the `oldNode` in
+     * the data structure.
+     * @returns the result of calling the `_replaceNode` method on the superclass, passing in the
+     * `oldNode` and `newNode` as arguments.
+     */
     protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
 }

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

@@ -10,9 +10,32 @@ exports.AVLTree = exports.AVLTreeNode = void 0;
  */
 const bst_1 = require("./bst");
 class AVLTreeNode extends bst_1.BSTNode {
+    /**
+     * The constructor function initializes a new instance of a class with a key and an optional value,
+     * and sets the height property to 0.
+     * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
+     * constructor. It is used to initialize the key property of the object being created.
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
+     * value associated with the key in the constructor.
+     */
     constructor(key, value) {
         super(key, value);
-        this.height = 0;
+        this._height = 0;
+    }
+    /**
+     * The function returns the value of the height property.
+     * @returns The height of the object.
+     */
+    get height() {
+        return this._height;
+    }
+    /**
+     * The above function sets the value of the height property.
+     * @param {number} value - The value parameter is a number that represents the new height value to be
+     * set.
+     */
+    set height(value) {
+        this._height = value;
     }
 }
 exports.AVLTreeNode = AVLTreeNode;
@@ -450,6 +473,15 @@ class AVLTree extends bst_1.BST {
             // TODO So far, no sure if this is necessary that Recursive Repair: Once rotation operations are executed, it may cause imbalance issues at higher levels of the tree. Therefore, you need to recursively check and repair imbalance problems upwards until you reach the root node.
         }
     }
+    /**
+     * The function replaces an old node with a new node while preserving the height of the old node.
+     * @param {NODE} oldNode - The `oldNode` parameter is the node that you want to replace with the
+     * `newNode`.
+     * @param {NODE} newNode - The `newNode` parameter is the new node that will replace the `oldNode` in
+     * the data structure.
+     * @returns the result of calling the `_replaceNode` method on the superclass, passing in the
+     * `oldNode` and `newNode` as arguments.
+     */
     _replaceNode(oldNode, newNode) {
         newNode.height = oldNode.height;
         return super._replaceNode(oldNode, newNode);

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

@@ -12,12 +12,34 @@ export declare class BinaryIndexedTree {
         max: number;
     });
     protected _freqMap: Record<number, number>;
+    /**
+     * The function returns the frequency map of numbers.
+     * @returns The `_freqMap` property, which is a record with number keys and number values, is being
+     * returned.
+     */
     get freqMap(): Record<number, number>;
     protected _msb: number;
+    /**
+     * The function returns the value of the _msb property.
+     * @returns The `_msb` property of the object.
+     */
     get msb(): number;
     protected _negativeCount: number;
+    /**
+     * The function returns the value of the _negativeCount property.
+     * @returns The method is returning the value of the variable `_negativeCount`, which is of type
+     * `number`.
+     */
     get negativeCount(): number;
+    /**
+     * The above function returns the value of the protected variable `_freq`.
+     * @returns The frequency value stored in the protected variable `_freq`.
+     */
     get freq(): number;
+    /**
+     * The above function returns the maximum value.
+     * @returns The maximum value stored in the variable `_max`.
+     */
     get max(): number;
     /**
      * The function "readSingle" reads a single number from a specified index.

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

@@ -23,18 +23,40 @@ class BinaryIndexedTree {
         this._msb = (0, utils_1.getMSB)(max);
         this._negativeCount = frequency < 0 ? max : 0;
     }
+    /**
+     * The function returns the frequency map of numbers.
+     * @returns The `_freqMap` property, which is a record with number keys and number values, is being
+     * returned.
+     */
     get freqMap() {
         return this._freqMap;
     }
+    /**
+     * The function returns the value of the _msb property.
+     * @returns The `_msb` property of the object.
+     */
     get msb() {
         return this._msb;
     }
+    /**
+     * The function returns the value of the _negativeCount property.
+     * @returns The method is returning the value of the variable `_negativeCount`, which is of type
+     * `number`.
+     */
     get negativeCount() {
         return this._negativeCount;
     }
+    /**
+     * The above function returns the value of the protected variable `_freq`.
+     * @returns The frequency value stored in the protected variable `_freq`.
+     */
     get freq() {
         return this._freq;
     }
+    /**
+     * The above function returns the maximum value.
+     * @returns The maximum value stored in the variable `_max`.
+     */
     get max() {
         return this._max;
     }

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

@@ -21,7 +21,7 @@ export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNod
     /**
      * The constructor function initializes an object with a key and an optional value.
      * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
-     * constructor. It is used to set the value of the "key" property of the object being created.
+     * constructor. It is used to set the key property of the object being created.
      * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
      * value associated with the key in the constructor.
      */

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

@@ -21,7 +21,7 @@ class BinaryTreeNode {
     /**
      * The constructor function initializes an object with a key and an optional value.
      * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
-     * constructor. It is used to set the value of the "key" property of the object being created.
+     * constructor. It is used to set the key property of the object being created.
      * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
      * value associated with the key in the constructor.
      */

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

@@ -13,10 +13,29 @@ export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE>
     parent?: NODE;
     constructor(key: K, value?: V);
     protected _left?: NODE;
+    /**
+     * The function returns the value of the `_left` property.
+     * @returns The `_left` property of the current object is being returned.
+     */
     get left(): NODE | undefined;
+    /**
+     * The function sets the left child of a node and updates the parent reference of the child.
+     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be an
+     * instance of the `NODE` class or `undefined`.
+     */
     set left(v: NODE | undefined);
     protected _right?: NODE;
+    /**
+     * The function returns the right node of a binary tree or undefined if there is no right node.
+     * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
+     * `undefined`.
+     */
     get right(): NODE | undefined;
+    /**
+     * The function sets the right child of a node and updates the parent reference of the child.
+     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be a
+     * `NODE` object or `undefined`.
+     */
     set right(v: NODE | undefined);
 }
 /**
@@ -30,33 +49,42 @@ export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE>
  */
 export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, NODE, TREE> = BST<K, V, NODE, BSTNested<K, V, NODE>>> extends BinaryTree<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
     /**
-     * This is the constructor function for a binary search tree class in TypeScript, which initializes
-     * the tree with optional keysOrNodesOrEntries and options.
-     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
-     * binary search tree.
+     * This is the constructor function for a TypeScript class that initializes a binary search tree with
+     * optional keys or nodes or entries and options.
+     * @param keysOrNodesOrEntries - An iterable object that contains keys, nodes, or entries. It is used
+     * to initialize the binary search tree with the provided keys, nodes, or entries.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary search tree. It can have the following properties:
      */
     constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: BSTOptions<K>);
     protected _root?: NODE;
+    /**
+     * The function returns the root node of a tree structure.
+     * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
+     */
     get root(): NODE | undefined;
     protected _variant: BSTVariant;
+    /**
+     * The function returns the value of the _variant property.
+     * @returns The value of the `_variant` property.
+     */
     get variant(): BSTVariant;
     /**
-     * The function creates a new binary search tree node with the given key and value.
-     * @param {K} key - The key parameter is the key value that will be associated with
-     * the new node. It is used to determine the position of the node in the binary search tree.
-     * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It
-     * represents the value associated with the node in a binary search tree.
-     * @returns a new instance of the BSTNode class with the specified key and value.
+     * The function creates a new BSTNode with the given key and value and returns it.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
+     * being created.
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
+     * value associated with the key in the node being created.
+     * @returns The method is returning a new instance of the BSTNode class, casted as the NODE type.
      */
     createNode(key: K, value?: V): NODE;
     /**
      * The function creates a new binary search tree with the specified options.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
-     * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which is a type
-     * that defines various options for creating a binary search tree.
-     * @returns a new instance of the BST class with the specified options.
+     * behavior of the `createTree` method. It is of type `Partial<BSTOptions<K>>`, which means it is a
+     * partial object of type `BSTOptions<K>`.
+     * @returns a new instance of the BST class, with the provided options merged with the default
+     * options. The returned value is casted as TREE.
      */
     createTree(options?: Partial<BSTOptions<K>>): TREE;
     /**
@@ -333,6 +361,11 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * @returns a boolean value.
      */
     isAVLBalanced(iterationType?: IterationType): boolean;
+    /**
+     * The function sets the root property of an object and updates the parent property of the new root.
+     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. This means that it
+     * can either be an object of type `NODE` or it can be `undefined`.
+     */
     protected _setRoot(v: NODE | undefined): void;
     /**
      * The function compares two values using a comparator function and returns whether the first value