data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BTree = void 0;
-class BTree {
-}
+var BTree = /** @class */ (function () {
+    function BTree() {
+    }
+    return BTree;
+}());
 exports.BTree = BTree;

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

@@ -1,8 +1,35 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 export declare class BinaryIndexedTree {
     private readonly _sumTree;
     constructor(n: number);
+    static lowBit(x: number): number;
+    /**
+     * The update function updates the values in a binary indexed tree by adding a delta value to the specified index and
+     * its ancestors.
+     * @param {number} i - The parameter `i` represents the index of the element in the `_sumTree` array that needs to be
+     * updated.
+     * @param {number} delta - The "delta" parameter represents the change in value that needs to be added to the element
+     * at index "i" in the "_sumTree" array.
+     */
     update(i: number, delta: number): void;
+    /**
+     * The function calculates the prefix sum of an array using a binary indexed tree.
+     * @param {number} i - The parameter "i" in the function "getPrefixSum" represents the index of the element in the
+     * array for which we want to calculate the prefix sum.
+     * @returns The function `getPrefixSum` returns the prefix sum of the elements in the binary indexed tree up to index
+     * `i`.
+     */
     getPrefixSum(i: number): number;
+    /**
+     * The function `getRangeSum` calculates the sum of a range of numbers in an array.
+     * @param {number} start - The start parameter is the starting index of the range for which we want to calculate the
+     * sum.
+     * @param {number} end - The "end" parameter represents the ending index of the range for which we want to calculate
+     * the sum.
+     * @returns the sum of the elements in the range specified by the start and end indices.
+     */
     getRangeSum(start: number, end: number): number;
-    static lowBit(x: number): number;
 }

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

@@ -1,31 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryIndexedTree = void 0;
-class BinaryIndexedTree {
-    constructor(n) {
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+var BinaryIndexedTree = /** @class */ (function () {
+    function BinaryIndexedTree(n) {
         this._sumTree = new Array(n + 1).fill(0);
     }
-    update(i, delta) {
+    BinaryIndexedTree.lowBit = function (x) {
+        return x & (-x);
+    };
+    /**
+     * The update function updates the values in a binary indexed tree by adding a delta value to the specified index and
+     * its ancestors.
+     * @param {number} i - The parameter `i` represents the index of the element in the `_sumTree` array that needs to be
+     * updated.
+     * @param {number} delta - The "delta" parameter represents the change in value that needs to be added to the element
+     * at index "i" in the "_sumTree" array.
+     */
+    BinaryIndexedTree.prototype.update = function (i, delta) {
         while (i < this._sumTree.length) {
             this._sumTree[i] += delta;
             i += BinaryIndexedTree.lowBit(i);
         }
-    }
-    getPrefixSum(i) {
-        let sum = 0;
+    };
+    /**
+     * The function calculates the prefix sum of an array using a binary indexed tree.
+     * @param {number} i - The parameter "i" in the function "getPrefixSum" represents the index of the element in the
+     * array for which we want to calculate the prefix sum.
+     * @returns The function `getPrefixSum` returns the prefix sum of the elements in the binary indexed tree up to index
+     * `i`.
+     */
+    BinaryIndexedTree.prototype.getPrefixSum = function (i) {
+        var sum = 0;
         while (i > 0) {
             sum += this._sumTree[i];
             i -= BinaryIndexedTree.lowBit(i);
         }
         return sum;
-    }
-    getRangeSum(start, end) {
+    };
+    /**
+     * The function `getRangeSum` calculates the sum of a range of numbers in an array.
+     * @param {number} start - The start parameter is the starting index of the range for which we want to calculate the
+     * sum.
+     * @param {number} end - The "end" parameter represents the ending index of the range for which we want to calculate
+     * the sum.
+     * @returns the sum of the elements in the range specified by the start and end indices.
+     */
+    BinaryIndexedTree.prototype.getRangeSum = function (start, end) {
         if (!(0 <= start && start <= end && end <= this._sumTree.length))
             throw 'Index out of bounds';
         return this.getPrefixSum(end) - this.getPrefixSum(start);
-    }
-    static lowBit(x) {
-        return x & (-x);
-    }
-}
+    };
+    return BinaryIndexedTree;
+}());
 exports.BinaryIndexedTree = BinaryIndexedTree;

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

@@ -1,18 +1,8 @@
-export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
-export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
-export type DFSOrderPattern = 'in' | 'pre' | 'post';
-export type BinaryTreeNodeId = number;
-export type BinaryTreeDeleted<T> = {
-    deleted: BinaryTreeNode<T> | null | undefined;
-    needBalanced: BinaryTreeNode<T> | null;
-};
-export type ResultByProperty<T> = T | BinaryTreeNode<T> | number | BinaryTreeNodeId;
-export type ResultsByProperty<T> = ResultByProperty<T>[];
-export interface BinaryTreeNodeObj<T> {
-    id: BinaryTreeNodeId;
-    val: T;
-    count?: number;
-}
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+import type { BinaryTreeDeleted, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName, ResultsByProperty } from '../types';
 export declare enum FamilyPosition {
     root = 0,
     left = 1,
@@ -23,6 +13,7 @@ export declare enum LoopType {
     recursive = 2
 }
 export declare class BinaryTreeNode<T> {
+    constructor(id: BinaryTreeNodeId, val: T, count?: number);
     protected _id: BinaryTreeNodeId;
     get id(): BinaryTreeNodeId;
     set id(v: BinaryTreeNodeId);
@@ -47,64 +38,224 @@ export declare class BinaryTreeNode<T> {
     protected _height: number;
     get height(): number;
     set height(v: number);
-    constructor(id: BinaryTreeNodeId, val: T, count?: number);
     swapLocation(swapNode: BinaryTreeNode<T>): BinaryTreeNode<T>;
     clone(): BinaryTreeNode<T>;
 }
 export declare class BinaryTree<T> {
-    protected _root: BinaryTreeNode<T> | null;
-    get root(): BinaryTreeNode<T> | null;
-    protected set root(v: BinaryTreeNode<T> | null);
-    protected _size: number;
-    get size(): number;
-    protected set size(v: number);
-    protected _count: number;
-    get count(): number;
-    protected set count(v: number);
-    private readonly _autoIncrementId;
-    private _maxId;
-    private readonly _isDuplicatedVal;
     protected _loopType: LoopType;
     protected _visitedId: BinaryTreeNodeId[];
     protected _visitedVal: Array<T>;
     protected _visitedNode: BinaryTreeNode<T>[];
     protected _visitedCount: number[];
     protected _visitedLeftSum: number[];
-    protected _resetResults(): void;
+    private readonly _autoIncrementId;
+    private _maxId;
+    private readonly _isDuplicatedVal;
+    /**
+     * The constructor function accepts an optional options object and sets the values of loopType, autoIncrementId, and
+     * isDuplicatedVal based on the provided options.
+     * @param [options] - An optional object that can contain the following properties:
+     */
     constructor(options?: {
         loopType?: LoopType;
         autoIncrementId?: boolean;
         isDuplicatedVal?: boolean;
     });
+    protected _root: BinaryTreeNode<T> | null;
+    get root(): BinaryTreeNode<T> | null;
+    protected set root(v: BinaryTreeNode<T> | null);
+    protected _size: number;
+    get size(): number;
+    protected set size(v: number);
+    protected _count: number;
+    get count(): number;
+    protected set count(v: number);
+    /**
+     * The function creates a new binary tree node with the given id, value, and count, or returns null if the value is
+     * null.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
+     * `BinaryTreeNodeId`, which could be a string or a number, depending on how you want to identify your nodes.
+     * @param {T | null} val - The `val` parameter represents the value to be stored in the binary tree node. It can be of
+     * any type `T` or `null`.
+     * @param {number} [count] - The count parameter is an optional parameter that represents the number of occurrences of
+     * the value in the binary tree node. It is of type number.
+     * @returns The function `createNode` returns a `BinaryTreeNode<T>` object if the `val` parameter is not null.
+     * Otherwise, it returns null.
+     */
     createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BinaryTreeNode<T> | null;
+    /**
+     * The clear function resets the state of an object by setting its properties to their initial values.
+     */
     clear(): void;
+    /**
+     * The function checks if the size of an object is equal to zero and returns a boolean value.
+     * @returns A boolean value indicating whether the size of the object is 0 or not.
+     */
     isEmpty(): boolean;
-    insertTo({ newNode, parent }: {
-        newNode: BinaryTreeNode<T> | null;
-        parent: BinaryTreeNode<T>;
-    }): 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.
+     */
+    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
+     * 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
+     * is inserted, or `undefined` if the insertion fails.
+     */
     put(id: BinaryTreeNodeId, val: T, count?: number): BinaryTreeNode<T> | null | undefined;
+    /**
+     * The `insertMany` 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.
+     */
     insertMany(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.
+     * @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 method is returning a boolean value.
+     */
     fill(data: T[] | BinaryTreeNode<T>[]): boolean;
+    /**
+     * The function removes a node from a binary tree and returns information about the deleted node.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to remove.
+     * It is of type `BinaryTreeNodeId`.
+     * @param {boolean} [ignoreCount] - The `ignoreCount` parameter is an optional boolean parameter that determines
+     * whether to ignore the count of the node being removed. If `ignoreCount` is set to `true`, the count of the node will
+     * not be decremented and the overall count of the binary tree will not be updated. If `
+     * @returns An array of objects is being returned. Each object in the array has two properties: "deleted" and
+     * "needBalanced". The "deleted" property contains the deleted node or undefined if no node was deleted. The
+     * "needBalanced" property is always null.
+     */
     remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeleted<T>[];
+    /**
+     * The function calculates the depth of a binary tree node by traversing its parent nodes.
+     * @param node - BinaryTreeNode<T> - This is the node for which we want to calculate the depth. It is a generic type,
+     * meaning it can represent any type of data that we want to store in the node.
+     * @returns The depth of the given binary tree node.
+     */
     getDepth(node: BinaryTreeNode<T>): number;
+    /**
+     * The `getHeight` function calculates the maximum height of a binary tree using either a recursive or iterative
+     * approach.
+     * @param {BinaryTreeNode<T> | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
+     * `BinaryTreeNode<T> | null`. It represents the starting node from which to calculate the height of the binary tree.
+     * If no value is provided for `beginRoot`, the function will use the `root` property of the class instance as
+     * @returns the height of the binary tree.
+     */
     getHeight(beginRoot?: BinaryTreeNode<T> | null): number;
+    /**
+     * The `getMinHeight` function calculates the minimum height of a binary tree using either a recursive or iterative
+     * approach.
+     * @param {BinaryTreeNode<T> | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
+     * `BinaryTreeNode<T> | null`. It represents the starting node from which to calculate the minimum height of the binary
+     * tree. If no value is provided for `beginRoot`, the function will use the root node of the binary tree.
+     * @returns The function `getMinHeight` returns the minimum height of the binary tree.
+     */
     getMinHeight(beginRoot?: BinaryTreeNode<T> | null): number;
+    /**
+     * The function checks if a binary tree is balanced by comparing the minimum height and the maximum height of the tree.
+     * @param {BinaryTreeNode<T> | null} [beginRoot] - The `beginRoot` parameter is the root node of a binary tree. It is
+     * of type `BinaryTreeNode<T> | null`, which means it can either be a `BinaryTreeNode` object or `null`.
+     * @returns The method is returning a boolean value.
+     */
     isBalanced(beginRoot?: BinaryTreeNode<T> | null): boolean;
+    /**
+     * The function `getNodes` returns an array of binary tree nodes that match a given property value, with options for
+     * searching recursively or iteratively.
+     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `T`. It represents the property of the binary tree node that you want to search for.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property name to use when searching for nodes. If not provided, it defaults to 'id'.
+     * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
+     * return only one node that matches the `nodeProperty` or `propertyName` criteria. If `onlyOne` is set to `true`, the
+     * function will stop traversing the tree and return the first matching node. If `
+     * @returns The function `getNodes` returns an array of `BinaryTreeNode<T> | null | undefined` objects.
+     */
     getNodes(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): (BinaryTreeNode<T> | null | undefined)[];
+    /**
+     * The function checks if a binary tree node has a specific property or if any node in the tree has a specific
+     * property.
+     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `T`. It represents the property of a binary tree node that you want to check.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the name of the property to check for in the nodes.
+     * @returns a boolean value.
+     */
     has(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): boolean;
+    /**
+     * The function returns the first binary tree node that matches the given property name and value, or null if no match
+     * is found.
+     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `T`. It represents the property of the binary tree node that you want to search for.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property of the binary tree node to search for. If not provided, it defaults to `'id'`.
+     * @returns a BinaryTreeNode object or null.
+     */
     get(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): BinaryTreeNode<T> | null;
+    /**
+     * The function getPathToRoot returns an array of BinaryTreeNode objects representing the path from a given node to the
+     * root of a binary tree.
+     * @param node - The `node` parameter is a BinaryTreeNode object.
+     * @returns The function `getPathToRoot` returns an array of `BinaryTreeNode<T>` objects, representing the path from
+     * the given `node` to the root of the binary tree.
+     */
     getPathToRoot(node: BinaryTreeNode<T>): BinaryTreeNode<T>[];
-    protected _pushByPropertyNameStopOrNot(cur: BinaryTreeNode<T>, result: (BinaryTreeNode<T> | null | undefined)[], nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): boolean | undefined;
-    protected _accumulatedByPropertyName(node: BinaryTreeNode<T>, nodeOrPropertyName?: NodeOrPropertyName): void;
-    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): ResultsByProperty<T>;
     getLeftMost(): BinaryTreeNode<T> | null;
     getLeftMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
     getRightMost(): BinaryTreeNode<T> | null;
     getRightMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
+    /**
+     * The `isBST` function checks if a binary tree is a binary search tree.
+     * @param {BinaryTreeNode<T> | null} [node] - The `node` parameter is an optional parameter of type `BinaryTreeNode<T>
+     * | null`. It represents the root node of the binary search tree (BST) that we want to check for validity. If no node
+     * is provided, the function will default to using the root node of the BST instance that
+     * @returns The `isBST` function returns a boolean value. It returns `true` if the binary tree is a valid binary search
+     * tree, and `false` otherwise.
+     */
     isBST(node?: BinaryTreeNode<T> | null): boolean;
+    /**
+     * The function calculates the size and count of a subtree in a binary tree using either recursive or iterative
+     * traversal.
+     * @param {BinaryTreeNode<T> | null | undefined} subTreeRoot - The `subTreeRoot` parameter is the root node of a binary
+     * tree.
+     * @returns The function `getSubTreeSizeAndCount` returns an array `[number, number]`. The first element of the array
+     * represents the size of the subtree, and the second element represents the count of the nodes in the subtree.
+     */
     getSubTreeSizeAndCount(subTreeRoot: BinaryTreeNode<T> | null | undefined): [number, number];
+    /**
+     * The function `subTreeSum` calculates the sum of a specified property in a binary tree, either recursively or
+     * iteratively.
+     * @param subTreeRoot - The subTreeRoot parameter is the root node of the subtree for which you want to calculate the
+     * sum.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property of the `BinaryTreeNode` object to use for calculating the sum. If `propertyName` is not
+     * provided, it defaults to `'val'`.
+     * @returns a number, which is the sum of the values of the nodes in the subtree rooted at `subTreeRoot`.
+     */
     subTreeSum(subTreeRoot: BinaryTreeNode<T>, propertyName?: BinaryTreeNodePropertyName): number;
+    /**
+     * The function `subTreeAdd` adds a specified delta value to a property of each node in a binary tree.
+     * @param subTreeRoot - The `subTreeRoot` parameter is the root node of the subtree where the values will be modified.
+     * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
+     * each node in the subtree should be increased or decreased.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property of the `BinaryTreeNode` that should be modified. It defaults to `'id'` if not provided.
+     * @returns a boolean value, which is `true`.
+     */
     subTreeAdd(subTreeRoot: BinaryTreeNode<T>, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
     BFS(): BinaryTreeNodeId[];
     BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
@@ -131,10 +282,53 @@ export declare class BinaryTree<T> {
     listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'val'): T[][];
     listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[][];
     listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'count'): number[][];
+    /**
+     * The function returns the predecessor of a given node in a binary tree.
+     * @param node - The parameter `node` is a BinaryTreeNode object, representing a node in a binary tree.
+     * @returns the predecessor of the given node in a binary tree.
+     */
     getPredecessor(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
     morris(): BinaryTreeNodeId[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    /**
+     * The function resets the values of several arrays used for tracking visited nodes and their properties.
+     */
+    protected _resetResults(): void;
+    /**
+     * The function checks if a given property of a binary tree node matches a specified value, and if so, adds the node to
+     * a result array.
+     * @param cur - The current binary tree node that is being checked.
+     * @param {(BinaryTreeNode<T> | null | undefined)[]} result - An array that stores the matching nodes found during the
+     * traversal.
+     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter is the value that we are searching for in
+     * the binary tree nodes. It can be either the `id`, `count`, or `val` property of the node.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property of the `BinaryTreeNode` object that you want to compare with the `nodeProperty` value. It can
+     * be one of the following values: 'id', 'count', or 'val'. If no `propertyName` is provided,
+     * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
+     * stop after finding the first matching node or continue searching for all matching nodes. If `onlyOne` is set to
+     * `true`, the function will stop after finding the first matching node and return `true`. If `onlyOne
+     * @returns a boolean value indicating whether or not a node was pushed into the result array.
+     */
+    protected _pushByPropertyNameStopOrNot(cur: BinaryTreeNode<T>, result: (BinaryTreeNode<T> | null | undefined)[], nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): boolean | undefined;
+    /**
+     * The function `_accumulatedByPropertyName` pushes a property value of a binary tree node into an array based on the
+     * provided property name or a default property name.
+     * @param node - The `node` parameter is of type `BinaryTreeNode<T>`, which represents a node in a binary tree.
+     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
+     * can be either a string representing a property name or a reference to a node object. If it is a string, it specifies
+     * the property name of the node that should be accumulated. If it is a node object, it specifies the node itself
+     */
+    protected _accumulatedByPropertyName(node: BinaryTreeNode<T>, nodeOrPropertyName?: NodeOrPropertyName): void;
+    /**
+     * The function `_getResultByPropertyName` returns different results based on the provided property name or defaulting
+     * to 'id'.
+     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
+     * can accept a value of type `NodeOrPropertyName`.
+     * @returns The method returns an object of type `ResultsByProperty<T>`.
+     */
+    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): ResultsByProperty<T>;
 }