data-structure-typed 1.12.11 → 1.12.21

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

@@ -1,18 +1,27 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import { BST, BSTNode } from './bst';
 import type { AVLTreeDeleted, BinaryTreeNodeId } from '../types';
 export declare class AVLTreeNode<T> extends BSTNode<T> {
+    /**
+     * The function overrides the clone method of the AVLTreeNode class to create a new AVLTreeNode object with the same
+     * id, value, and count.
+     * @returns The method is returning a new instance of the AVLTreeNode class with the same id, val, and count values as
+     * the current instance.
+     */
     clone(): AVLTreeNode<T>;
 }
 export declare class AVLTree<T> extends BST<T> {
     createNode(id: BinaryTreeNodeId, val: T, count?: number): AVLTreeNode<T>;
     /**
-     * The function overrides the put method of a Binary Search Tree to insert a node with a given id and value, and then
+     * The function overrides the add method of a Binary Search Tree to insert a node with a given id and value, and then
      * balances the tree.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to put or
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add or
      * update in the AVL tree.
      * @param {T | null} val - The `val` parameter represents the value that you want to assign to the node with the given
      * `id`. It can be of type `T` (the generic type) or `null`.
@@ -21,7 +30,7 @@ export declare class AVLTree<T> extends BST<T> {
      * to `1`, indicating that the value should be inserted once.
      * @returns The method is returning either an AVLTreeNode<T> object or null.
      */
-    put(id: BinaryTreeNodeId, val: T | null, count?: number): AVLTreeNode<T> | null;
+    add(id: BinaryTreeNodeId, val: T | null, count?: number): AVLTreeNode<T> | null;
     /**
      * The function overrides the remove method of the Binary Search Tree class, performs the removal operation, and
      * then balances the tree if necessary.

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

@@ -28,8 +28,11 @@ var __values = (this && this.__values) || function(o) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AVLTree = exports.AVLTreeNode = void 0;
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var bst_1 = require("./bst");
 var AVLTreeNode = /** @class */ (function (_super) {
@@ -37,6 +40,12 @@ var AVLTreeNode = /** @class */ (function (_super) {
     function AVLTreeNode() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * The function overrides the clone method of the AVLTreeNode class to create a new AVLTreeNode object with the same
+     * id, value, and count.
+     * @returns The method is returning a new instance of the AVLTreeNode class with the same id, val, and count values as
+     * the current instance.
+     */
     AVLTreeNode.prototype.clone = function () {
         return new AVLTreeNode(this.id, this.val, this.count);
     };
@@ -52,9 +61,9 @@ var AVLTree = /** @class */ (function (_super) {
         return new AVLTreeNode(id, val, count);
     };
     /**
-     * The function overrides the put method of a Binary Search Tree to insert a node with a given id and value, and then
+     * The function overrides the add method of a Binary Search Tree to insert a node with a given id and value, and then
      * balances the tree.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to put or
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add or
      * update in the AVL tree.
      * @param {T | null} val - The `val` parameter represents the value that you want to assign to the node with the given
      * `id`. It can be of type `T` (the generic type) or `null`.
@@ -63,8 +72,8 @@ var AVLTree = /** @class */ (function (_super) {
      * to `1`, indicating that the value should be inserted once.
      * @returns The method is returning either an AVLTreeNode<T> object or null.
      */
-    AVLTree.prototype.put = function (id, val, count) {
-        var inserted = _super.prototype.put.call(this, id, val, count);
+    AVLTree.prototype.add = function (id, val, count) {
+        var inserted = _super.prototype.add.call(this, id, val, count);
         if (inserted)
             this.balancePath(inserted);
         return inserted;

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

@@ -1,9 +1,18 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 export declare class BinaryIndexedTree {
     private readonly _sumTree;
+    /**
+     * The constructor initializes an array with a specified length and fills it with zeros.
+     * @param {number} n - The parameter `n` represents the size of the array that will be used to store the sum tree. The
+     * sum tree is a binary tree data structure used to efficiently calculate the sum of a range of elements in an array.
+     * The size of the sum tree array is `n + 1` because
+     */
     constructor(n: number);
     static lowBit(x: number): number;
     /**

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

@@ -2,10 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryIndexedTree = void 0;
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var BinaryIndexedTree = /** @class */ (function () {
+    /**
+     * The constructor initializes an array with a specified length and fills it with zeros.
+     * @param {number} n - The parameter `n` represents the size of the array that will be used to store the sum tree. The
+     * sum tree is a binary tree data structure used to efficiently calculate the sum of a range of elements in an array.
+     * The size of the sum tree array is `n + 1` because
+     */
     function BinaryIndexedTree(n) {
         this._sumTree = new Array(n + 1).fill(0);
     }

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

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import type { BinaryTreeDeleted, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName, ResultsByProperty } from '../types';
 export declare enum FamilyPosition {
@@ -8,6 +11,12 @@ export declare enum FamilyPosition {
     left = 1,
     right = 2
 }
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
 export declare enum LoopType {
     iterative = 1,
     recursive = 2
@@ -93,34 +102,34 @@ export declare class BinaryTree<T> {
      */
     isEmpty(): boolean;
     /**
-     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
-     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
-     * `null`. It represents the node that needs to be inserted into the binary tree.
-     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
-     * will be inserted as a child.
-     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
-     */
-    putTo(newNode: BinaryTreeNode<T> | null, parent: BinaryTreeNode<T>): BinaryTreeNode<T> | null | undefined;
-    /**
-     * The `put` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
+     * The `add` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
      * already exists.
      * @param {BinaryTreeNodeId} id - The id parameter is the identifier of the binary tree node. It is used to uniquely
      * identify each node in the binary tree.
      * @param {T} val - The value to be inserted into the binary tree.
      * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
      * value should be inserted into the binary tree. If not provided, it defaults to 1.
-     * @returns The function `put` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
+     * @returns The function `add` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
      * is inserted, or `undefined` if the insertion fails.
      */
-    put(id: BinaryTreeNodeId, val: T, count?: number): BinaryTreeNode<T> | null | undefined;
+    add(id: BinaryTreeNodeId, val: T, count?: number): BinaryTreeNode<T> | null | undefined;
+    /**
+     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
+     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
+     * `null`. It represents the node that needs to be inserted into the binary tree.
+     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
+     * will be inserted as a child.
+     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
+     */
+    addTo(newNode: BinaryTreeNode<T> | null, parent: BinaryTreeNode<T>): BinaryTreeNode<T> | null | undefined;
     /**
-     * The `insertMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
+     * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
      * null/undefined values.
      * @param {T[] | BinaryTreeNode<T>[]} data - The `data` parameter can be either an array of elements of type `T` or an
      * array of `BinaryTreeNode<T>` objects.
-     * @returns The function `insertMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
+     * @returns The function `addMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
      */
-    insertMany(data: T[] | BinaryTreeNode<T>[]): (BinaryTreeNode<T> | null | undefined)[];
+    addMany(data: T[] | BinaryTreeNode<T>[]): (BinaryTreeNode<T> | null | undefined)[];
     /**
      * The `fill` function clears the current data and inserts new data, returning a boolean indicating if the insertion
      * was successful.

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

@@ -1,7 +1,10 @@
 "use strict";
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
@@ -32,13 +35,20 @@ var __read = (this && this.__read) || function (o, n) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryTree = exports.BinaryTreeNode = exports.LoopType = exports.FamilyPosition = void 0;
-var trampoline_1 = require("../../utils/trampoline");
+var utils_1 = require("../../utils");
+/* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
 var FamilyPosition;
 (function (FamilyPosition) {
     FamilyPosition[FamilyPosition["root"] = 0] = "root";
     FamilyPosition[FamilyPosition["left"] = 1] = "left";
     FamilyPosition[FamilyPosition["right"] = 2] = "right";
 })(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
 var LoopType;
 (function (LoopType) {
     LoopType[LoopType["iterative"] = 1] = "iterative";
@@ -255,60 +265,17 @@ var BinaryTree = /** @class */ (function () {
         return this.size === 0;
     };
     /**
-     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
-     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
-     * `null`. It represents the node that needs to be inserted into the binary tree.
-     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
-     * will be inserted as a child.
-     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
-     */
-    BinaryTree.prototype.putTo = function (newNode, parent) {
-        var _a, _b;
-        if (parent) {
-            if (parent.left === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                    newNode.familyPosition = FamilyPosition.left;
-                }
-                parent.left = newNode;
-                if (newNode !== null) {
-                    this.size++;
-                    this.count += (_a = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _a !== void 0 ? _a : 0;
-                }
-                return parent.left;
-            }
-            else if (parent.right === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                    newNode.familyPosition = FamilyPosition.right;
-                }
-                parent.right = newNode;
-                if (newNode !== null) {
-                    this.size++;
-                    this.count += (_b = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _b !== void 0 ? _b : 0;
-                }
-                return parent.right;
-            }
-            else {
-                return;
-            }
-        }
-        else {
-            return;
-        }
-    };
-    /**
-     * The `put` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
+     * The `add` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
      * already exists.
      * @param {BinaryTreeNodeId} id - The id parameter is the identifier of the binary tree node. It is used to uniquely
      * identify each node in the binary tree.
      * @param {T} val - The value to be inserted into the binary tree.
      * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
      * value should be inserted into the binary tree. If not provided, it defaults to 1.
-     * @returns The function `put` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
+     * @returns The function `add` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
      * is inserted, or `undefined` if the insertion fails.
      */
-    BinaryTree.prototype.put = function (id, val, count) {
+    BinaryTree.prototype.add = function (id, val, count) {
         var _this = this;
         count = count !== null && count !== void 0 ? count : 1;
         var _bfs = function (root, newNode) {
@@ -316,7 +283,7 @@ var BinaryTree = /** @class */ (function () {
             while (queue.length > 0) {
                 var cur = queue.shift();
                 if (cur) {
-                    var inserted_1 = _this.putTo(newNode, cur);
+                    var inserted_1 = _this.addTo(newNode, cur);
                     if (inserted_1 !== undefined)
                         return inserted_1;
                     if (cur.left)
@@ -356,13 +323,56 @@ var BinaryTree = /** @class */ (function () {
         return inserted;
     };
     /**
-     * The `insertMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
+     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
+     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
+     * `null`. It represents the node that needs to be inserted into the binary tree.
+     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
+     * will be inserted as a child.
+     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
+     */
+    BinaryTree.prototype.addTo = function (newNode, parent) {
+        var _a, _b;
+        if (parent) {
+            if (parent.left === undefined) {
+                if (newNode) {
+                    newNode.parent = parent;
+                    newNode.familyPosition = FamilyPosition.left;
+                }
+                parent.left = newNode;
+                if (newNode !== null) {
+                    this.size++;
+                    this.count += (_a = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _a !== void 0 ? _a : 0;
+                }
+                return parent.left;
+            }
+            else if (parent.right === undefined) {
+                if (newNode) {
+                    newNode.parent = parent;
+                    newNode.familyPosition = FamilyPosition.right;
+                }
+                parent.right = newNode;
+                if (newNode !== null) {
+                    this.size++;
+                    this.count += (_b = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _b !== void 0 ? _b : 0;
+                }
+                return parent.right;
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+    };
+    /**
+     * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
      * null/undefined values.
      * @param {T[] | BinaryTreeNode<T>[]} data - The `data` parameter can be either an array of elements of type `T` or an
      * array of `BinaryTreeNode<T>` objects.
-     * @returns The function `insertMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
+     * @returns The function `addMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
      */
-    BinaryTree.prototype.insertMany = function (data) {
+    BinaryTree.prototype.addMany = function (data) {
         var e_1, _a, e_2, _b;
         var _c;
         var inserted = [];
@@ -387,33 +397,33 @@ var BinaryTree = /** @class */ (function () {
                 var item = data_2_1.value;
                 var count = this._isDuplicatedVal ? 1 : map.get(item);
                 if (item instanceof BinaryTreeNode) {
-                    inserted.push(this.put(item.id, item.val, item.count));
+                    inserted.push(this.add(item.id, item.val, item.count));
                 }
                 else if (typeof item === 'number' && !this._autoIncrementId) {
                     if (!this._isDuplicatedVal) {
                         if (map.get(item) !== undefined) {
-                            inserted.push(this.put(item, item, count));
+                            inserted.push(this.add(item, item, count));
                             map.delete(item);
                         }
                     }
                     else {
-                        inserted.push(this.put(item, item, 1));
+                        inserted.push(this.add(item, item, 1));
                     }
                 }
                 else {
                     if (item !== null) {
                         if (!this._isDuplicatedVal) {
                             if (map.get(item) !== undefined) {
-                                inserted.push(this.put(++this._maxId, item, count));
+                                inserted.push(this.add(++this._maxId, item, count));
                                 map.delete(item);
                             }
                         }
                         else {
-                            inserted.push(this.put(++this._maxId, item, 1));
+                            inserted.push(this.add(++this._maxId, item, 1));
                         }
                     }
                     else {
-                        inserted.push(this.put(Number.MAX_SAFE_INTEGER, item, 0));
+                        inserted.push(this.add(Number.MAX_SAFE_INTEGER, item, 0));
                     }
                 }
             }
@@ -436,7 +446,7 @@ var BinaryTree = /** @class */ (function () {
      */
     BinaryTree.prototype.fill = function (data) {
         this.clear();
-        return data.length === this.insertMany(data).length;
+        return data.length === this.addMany(data).length;
     };
     /**
      * The function removes a node from a binary tree and returns information about the deleted node.
@@ -718,7 +728,7 @@ var BinaryTree = /** @class */ (function () {
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            var _traverse_3 = (0, trampoline_1.trampoline)(function (cur) {
+            var _traverse_3 = (0, utils_1.trampoline)(function (cur) {
                 if (!cur.left)
                     return cur;
                 return _traverse_3.cont(cur.left);
@@ -748,7 +758,7 @@ var BinaryTree = /** @class */ (function () {
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            var _traverse_5 = (0, trampoline_1.trampoline)(function (cur) {
+            var _traverse_5 = (0, utils_1.trampoline)(function (cur) {
                 if (!cur.right)
                     return cur;
                 return _traverse_5.cont(cur.right);

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

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTDeletedResult } from '../types';
 import { BinaryTree, BinaryTreeNode, LoopType } from './binary-tree';
@@ -13,13 +16,17 @@ export declare class BSTNode<T> extends BinaryTreeNode<T> {
     clone(): BSTNode<T>;
 }
 export declare class BST<T> extends BinaryTree<T> {
+    /**
+     * The constructor function accepts an optional options object and sets the comparator property if provided.
+     * @param [options] - An optional object that can contain the following properties:
+     */
     constructor(options?: {
         comparator?: BSTComparator;
         loopType?: LoopType;
     });
     createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
     /**
-     * The `put` function inserts a new node into a binary search tree, updating the count and value of an existing node if
+     * The `add` function inserts a new node into a binary search tree, updating the count and value of an existing node if
      * the ID matches, and returns the inserted node.
      * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node. It is used to
      * determine the position of the node in the binary search tree.
@@ -28,17 +35,97 @@ export declare class BST<T> extends BinaryTree<T> {
      * @param {number} [count=1] - The `count` parameter represents the number of times the value should be inserted into
      * the binary search tree. By default, it is set to 1, meaning that if no count is specified, the value will be
      * inserted once.
-     * @returns The method `put` returns a `BSTNode<T>` object or `null`.
+     * @returns The method `add` returns a `BSTNode<T>` object or `null`.
+     */
+    add(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
+    /**
+     * The `get` function returns the first node in a binary search tree that matches the given property value or name.
+     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `T`. It represents the value of the property that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property name to use for searching the binary search tree nodes. If not provided, it defaults to
+     * `'id'`.
+     * @returns The method is returning a BSTNode<T> object or null.
      */
-    put(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
     get(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): BSTNode<T> | null;
+    /**
+     * The function returns the id of the rightmost node if the comparison between two values is less than, the id of the
+     * leftmost node if the comparison is greater than, and the id of the rightmost node otherwise.
+     * @returns The function `lastKey()` returns the ID of the rightmost node in a binary tree. If the comparison between
+     * the first two elements in the tree is less than, it returns the ID of the rightmost node. If the comparison is
+     * greater than, it returns the ID of the leftmost node. Otherwise, it also returns the ID of the rightmost node. If
+     * there are no nodes in
+     */
     lastKey(): number;
+    /**
+     * The `remove` function in this TypeScript code removes a node from a binary search tree and returns information about
+     * the deleted node and any nodes that need to be balanced.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that needs to be removed
+     * from the binary search tree.
+     * @param {boolean} [ignoreCount] - A boolean flag indicating whether to ignore the count of the node being removed. If
+     * set to true, the count of the node will not be considered and the node will be removed regardless of its count. If
+     * set to false or not provided, the count of the node will be taken into account and the
+     * @returns an array of `BSTDeletedResult<T>` objects.
+     */
     remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BSTDeletedResult<T>[];
+    /**
+     * The function `getNodes` returns an array of binary search tree nodes that match a given property value, with the
+     * option to specify the property name and whether to return only one node.
+     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `T`. It represents the property value that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property of the nodes to compare with the `nodeProperty` parameter. If not provided, it defaults to
+     * `'id'`.
+     * @param {boolean} [onlyOne] - A boolean value indicating whether to return only one node that matches the given
+     * nodeProperty. If set to true, the function will stop traversing the tree and return the first matching node. If set
+     * to false or not provided, the function will return all nodes that match the given nodeProperty.
+     * @returns an array of BSTNode<T> objects.
+     */
     getNodes(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): BSTNode<T>[];
+    /**
+     * The `lesserSum` function calculates the sum of a specified property in all nodes with an ID less than a given ID in
+     * a binary search tree.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node for which you want to
+     * calculate the lesser sum.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property of the binary tree node to use for calculating the sum. If not provided, it defaults to 'id'.
+     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
+     * binary search tree that have a property value lesser than the given `id`.
+     */
     lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
+    /**
+     * The function `allGreaterNodesAdd` updates the value of a specified property for all nodes in a binary search tree
+     * that have a greater value than a given node.
+     * @param node - The `node` parameter is of type `BSTNode<T>`, which represents a node in a binary search tree. It
+     * contains properties such as `id` and `count`.
+     * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
+     * each node should be increased.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - propertyName is an optional parameter that specifies the
+     * property of the BSTNode to be modified. It can be either 'id' or 'count'. If propertyName is not provided, it
+     * defaults to 'id'.
+     * @returns a boolean value.
+     */
     allGreaterNodesAdd(node: BSTNode<T>, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    /**
+     * The `balance` function takes a sorted array of nodes and builds a balanced binary search tree using either a
+     * recursive or iterative approach.
+     * @returns The `balance()` function returns a boolean value.
+     */
     balance(): boolean;
+    /**
+     * The function `isAVLBalanced` checks if a binary search tree is balanced according to the AVL tree property.
+     * @returns The function `isAVLBalanced()` returns a boolean value. It returns `true` if the binary search tree (BST)
+     * is balanced according to the AVL tree property, and `false` otherwise.
+     */
     isAVLBalanced(): boolean;
     protected _comparator: BSTComparator;
+    /**
+     * The function compares two binary tree node IDs using a comparator function and returns whether the first ID is
+     * greater than, less than, or equal to the second ID.
+     * @param {BinaryTreeNodeId} a - a is a BinaryTreeNodeId, which represents the identifier of a binary tree node.
+     * @param {BinaryTreeNodeId} b - The parameter "b" in the above code refers to a BinaryTreeNodeId.
+     * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater than), CP.lt (less
+     * than), or CP.eq (equal).
+     */
     protected _compare(a: BinaryTreeNodeId, b: BinaryTreeNodeId): CP;
 }