data-structure-typed 1.18.0 → 1.18.5

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

@@ -5,7 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleted, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName, ResultsByProperty } from '../types';
+import type { BinaryTreeDeleted, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName, RecursiveBinaryTreeNode, ResultsByProperty } from '../types';
+import { IBinaryTree, IBinaryTreeNode } from '../interfaces';
 export declare enum FamilyPosition {
     root = 0,
     left = 1,
@@ -21,7 +22,7 @@ export declare enum LoopType {
     iterative = 1,
     recursive = 2
 }
-export declare class BinaryTreeNode<T> {
+export declare class BinaryTreeNode<T, FAMILY extends BinaryTreeNode<T, FAMILY> = RecursiveBinaryTreeNode<T>> implements IBinaryTreeNode<T, FAMILY> {
     constructor(id: BinaryTreeNodeId, val: T, count?: number);
     private _id;
     get id(): BinaryTreeNodeId;
@@ -30,14 +31,14 @@ export declare class BinaryTreeNode<T> {
     get val(): T;
     set val(v: T);
     private _left?;
-    get left(): BinaryTreeNode<T> | null | undefined;
-    set left(v: BinaryTreeNode<T> | null | undefined);
+    get left(): FAMILY | null | undefined;
+    set left(v: FAMILY | null | undefined);
     private _right?;
-    get right(): BinaryTreeNode<T> | null | undefined;
-    set right(v: BinaryTreeNode<T> | null | undefined);
+    get right(): FAMILY | null | undefined;
+    set right(v: FAMILY | null | undefined);
     private _parent;
-    get parent(): BinaryTreeNode<T> | null | undefined;
-    set parent(v: BinaryTreeNode<T> | null | undefined);
+    get parent(): FAMILY | null | undefined;
+    set parent(v: FAMILY | null | undefined);
     private _familyPosition;
     get familyPosition(): FamilyPosition;
     set familyPosition(v: FamilyPosition);
@@ -47,10 +48,11 @@ export declare class BinaryTreeNode<T> {
     private _height;
     get height(): number;
     set height(v: number);
-    swapLocation(swapNode: BinaryTreeNode<T>): BinaryTreeNode<T>;
-    clone(): BinaryTreeNode<T>;
+    _createNode(id: BinaryTreeNodeId, val: T | null, count?: number): FAMILY | null;
+    swapLocation(swapNode: FAMILY): FAMILY;
+    clone(): FAMILY | null;
 }
-export declare class BinaryTree<T> {
+export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode<number>> implements IBinaryTree<N> {
     /**
      * The constructor function accepts an optional options object and sets the values of loopType, autoIncrementId, and
      * isDuplicatedVal based on the provided options.
@@ -66,9 +68,9 @@ export declare class BinaryTree<T> {
     private _visitedId;
     get visitedId(): BinaryTreeNodeId[];
     private _visitedVal;
-    get visitedVal(): Array<T>;
+    get visitedVal(): Array<N['val']>;
     private _visitedNode;
-    get visitedNode(): BinaryTreeNode<T>[];
+    get visitedNode(): N[];
     private _visitedCount;
     get visitedCount(): number[];
     private _visitedLeftSum;
@@ -80,24 +82,23 @@ export declare class BinaryTree<T> {
     private _isDuplicatedVal;
     get isDuplicatedVal(): boolean;
     private _root;
-    get root(): BinaryTreeNode<T> | null;
+    get root(): N | null;
     private _size;
     get size(): number;
     private _count;
     get count(): number;
     /**
-     * The function creates a new binary tree node with the given id, value, and count, or returns null if the value is
-     * null.
+     * The function creates a new binary tree node with the given id, value, and count if the value is not null, otherwise
+     * it returns 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.
+     * `BinaryTreeNodeId`.
+     * @param {N | null} val - The `val` parameter represents the value of the node. It can be of type `N` (generic type)
+     * or `null`.
+     * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
+     * of occurrences of the value in the binary tree node. If not provided, the default value is `undefined`.
+     * @returns a BinaryTreeNode object if the value is not null, otherwise it returns null.
      */
-    createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BinaryTreeNode<T> | null;
+    _createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
     /**
      * The clear function resets the state of an object by setting its properties to their initial values.
      */
@@ -112,38 +113,38 @@ export declare class BinaryTree<T> {
      * 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 {N} 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 `add` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
+     * @returns The function `add` returns a `N` object if a new node is inserted, or `null` if no new node
      * is inserted, or `undefined` if the insertion fails.
      */
-    add(id: BinaryTreeNodeId, val: T, count?: number): BinaryTreeNode<T> | null | undefined;
+    add(id: BinaryTreeNodeId, val: N['val'], count?: number): N | 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
+     * @param {N | 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;
+    addTo(newNode: N | null, parent: N): N | null | undefined;
     /**
      * 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 `addMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
+     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
+     * array of `N` objects.
+     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(data: T[] | BinaryTreeNode<T>[]): (BinaryTreeNode<T> | null | undefined)[];
+    addMany(data: N[] | Array<N['val']>): (N | 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.
+     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
+     * array of `N` objects.
      * @returns The method is returning a boolean value.
      */
-    fill(data: T[] | BinaryTreeNode<T>[]): boolean;
+    fill(data: N[] | Array<N['val']>): 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.
@@ -155,102 +156,102 @@ export declare class BinaryTree<T> {
      * "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>[];
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeleted<N>[];
     /**
      * 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,
+     * @param node - N - 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;
+    getDepth(node: N): 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.
+     * @param {N | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
+     * `N | 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;
+    getHeight(beginRoot?: N | 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
+     * @param {N | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
+     * `N | 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;
+    getMinHeight(beginRoot?: N | 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`.
+     * @param {N | null} [beginRoot] - The `beginRoot` parameter is the root node of a binary tree. It is
+     * of type `N | 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;
+    isBalanced(beginRoot?: N | 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 {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. 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.
+     * @returns The function `getNodes` returns an array of `N | null | undefined` objects.
      */
-    getNodes(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): (BinaryTreeNode<T> | null | undefined)[];
+    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): (N | 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 {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. 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;
+    has(nodeProperty: BinaryTreeNodeId | N, 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 {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. 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;
+    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | 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
+     * @returns The function `getPathToRoot` returns an array of `N` objects, representing the path from
      * the given `node` to the root of the binary tree.
      */
-    getPathToRoot(node: BinaryTreeNode<T>): BinaryTreeNode<T>[];
-    getLeftMost(): BinaryTreeNode<T> | null;
-    getLeftMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
-    getRightMost(): BinaryTreeNode<T> | null;
-    getRightMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
+    getPathToRoot(node: N): N[];
+    getLeftMost(): N | null;
+    getLeftMost(node: N): N;
+    getRightMost(): N | null;
+    getRightMost(node: N): N;
     /**
      * 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>
+     * @param {N | null} [node] - The `node` parameter is an optional parameter of type `N
      * | 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;
+    isBST(node?: N | 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
+     * @param {N | 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];
+    getSubTreeSizeAndCount(subTreeRoot: N | null | undefined): [number, number];
     /**
      * The function `subTreeSum` calculates the sum of a specified property in a binary tree, either recursively or
      * iteratively.
@@ -261,7 +262,7 @@ export declare class BinaryTree<T> {
      * 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;
+    subTreeSum(subTreeRoot: N, 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.
@@ -271,53 +272,53 @@ export declare class BinaryTree<T> {
      * 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;
+    subTreeAdd(subTreeRoot: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
     BFS(): BinaryTreeNodeId[];
     BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
-    BFS(nodeOrPropertyName: 'val'): T[];
-    BFS(nodeOrPropertyName: 'node'): BinaryTreeNode<T>[];
+    BFS(nodeOrPropertyName: 'val'): N['val'][];
+    BFS(nodeOrPropertyName: 'node'): N[];
     BFS(nodeOrPropertyName: 'count'): number[];
     DFS(): BinaryTreeNodeId[];
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
     DFSIterative(): BinaryTreeNodeId[];
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
-    levelIterative(node: BinaryTreeNode<T> | null): BinaryTreeNodeId[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'val'): T[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
-    levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'count'): number[];
-    listLevels(node: BinaryTreeNode<T> | null): BinaryTreeNodeId[][];
-    listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
-    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[][];
+    levelIterative(node: N | null): BinaryTreeNodeId[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'val'): N['val'][];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'node'): N[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'count'): number[];
+    listLevels(node: N | null): BinaryTreeNodeId[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'val'): N['val'][][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'node'): N[][];
+    listLevels(node: N | 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>;
+    getPredecessor(node: N): N;
     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?: 'val'): N[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
     protected _setLoopType(value: LoopType): void;
     protected _setVisitedId(value: BinaryTreeNodeId[]): void;
-    protected _setVisitedVal(value: Array<T>): void;
-    protected _setVisitedNode(value: BinaryTreeNode<T>[]): void;
+    protected _setVisitedVal(value: Array<N>): void;
+    protected _setVisitedNode(value: N[]): void;
     protected setVisitedCount(value: number[]): void;
     protected _setVisitedLeftSum(value: number[]): void;
     protected _setAutoIncrementId(value: boolean): void;
     protected _setMaxId(value: number): void;
     protected _setIsDuplicatedVal(value: boolean): void;
-    protected _setRoot(v: BinaryTreeNode<T> | null): void;
+    protected _setRoot(v: N | null): void;
     protected _setSize(v: number): void;
     protected _setCount(v: number): void;
     /**
@@ -328,9 +329,9 @@ export declare class BinaryTree<T> {
      * 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
+     * @param {(N | 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
+     * @param {BinaryTreeNodeId | N} 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
@@ -340,16 +341,16 @@ export declare class BinaryTree<T> {
      * `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;
+    protected _pushByPropertyNameStopOrNot(cur: N, result: (N | null | undefined)[], nodeProperty: BinaryTreeNodeId | N, 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 node - The `node` parameter is of type `N`, 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;
+    protected _accumulatedByPropertyName(node: N, nodeOrPropertyName?: NodeOrPropertyName): void;
     /**
      * The function `_getResultByPropertyName` returns different results based on the provided property name or defaulting
      * to 'id'.
@@ -357,5 +358,5 @@ export declare class BinaryTree<T> {
      * can accept a value of type `NodeOrPropertyName`.
      * @returns The method returns an object of type `ResultsByProperty<T>`.
      */
-    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): ResultsByProperty<T>;
+    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): ResultsByProperty<N>;
 }