tree-multimap-typed 2.1.2 → 2.2.1

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

@@ -5,16 +5,18 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeCounterOptions, BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, IterationType } from '../../types';
+import type { AVLTreeCounterOptions, BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, FamilyPosition, IterationType, RBTNColor } from '../../types';
 import { IBinaryTree } from '../../interfaces';
-import { AVLTree, AVLTreeNode } from './avl-tree';
+import { AVLTree } from './avl-tree';
 /**
  * AVL node with an extra 'count' field; keeps parent/child links.
  * @remarks Time O(1), Space O(1)
  * @template K
  * @template V
  */
-export declare class AVLTreeCounterNode<K = any, V = any> extends AVLTreeNode<K, V> {
+export declare class AVLTreeCounterNode<K = any, V = any> {
+    key: K;
+    value?: V;
     parent?: AVLTreeCounterNode<K, V>;
     /**
      * Create an AVL counter node.
@@ -53,6 +55,58 @@ export declare class AVLTreeCounterNode<K = any, V = any> extends AVLTreeNode<K,
      * @returns void
      */
     set right(v: AVLTreeCounterNode<K, V> | null | undefined);
+    _height: number;
+    /**
+     * Gets the height of the node (used in self-balancing trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The height.
+     */
+    get height(): number;
+    /**
+     * Sets the height of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new height.
+     */
+    set height(value: number);
+    _color: RBTNColor;
+    /**
+     * Gets the color of the node (used in Red-Black trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The node's color.
+     */
+    get color(): RBTNColor;
+    /**
+     * Sets the color of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new color.
+     */
+    set color(value: RBTNColor);
+    _count: number;
+    /**
+     * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The subtree node count.
+     */
+    get count(): number;
+    /**
+     * Sets the count of nodes in the subtree.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new count.
+     */
+    set count(value: number);
+    /**
+     * Gets the position of the node relative to its parent.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+     */
+    get familyPosition(): FamilyPosition;
 }
 /**
  * AVL tree that tracks an aggregate 'count' across nodes; supports balanced insert/delete and map-like mode.

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeMultiMapOptions, AVLTreeOptions, ElemOf, EntryCallback, IterationType } from '../../types';
+import type { AVLTreeMultiMapOptions, AVLTreeOptions, ElemOf, EntryCallback, FamilyPosition, IterationType, RBTNColor } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 import { IBinaryTree } from '../../interfaces';
 /**
@@ -14,7 +14,9 @@ import { IBinaryTree } from '../../interfaces';
  * @template K
  * @template V
  */
-export declare class AVLTreeMultiMapNode<K = any, V = any> extends AVLTreeNode<K, V[]> {
+export declare class AVLTreeMultiMapNode<K = any, V = any> {
+    key: K;
+    value?: V[];
     parent?: AVLTreeMultiMapNode<K, V>;
     /**
      * Create an AVLTreeMultiMap node with a value bucket.
@@ -23,7 +25,7 @@ export declare class AVLTreeMultiMapNode<K = any, V = any> extends AVLTreeNode<K
      * @param value - Initial array of values.
      * @returns New AVLTreeMultiMapNode instance.
      */
-    constructor(key: K, value: V[]);
+    constructor(key: K, value?: V[]);
     _left?: AVLTreeMultiMapNode<K, V> | null | undefined;
     /**
      * Get the left child pointer.
@@ -52,6 +54,58 @@ export declare class AVLTreeMultiMapNode<K = any, V = any> extends AVLTreeNode<K
      * @returns void
      */
     set right(v: AVLTreeMultiMapNode<K, V> | null | undefined);
+    _height: number;
+    /**
+     * Gets the height of the node (used in self-balancing trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The height.
+     */
+    get height(): number;
+    /**
+     * Sets the height of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new height.
+     */
+    set height(value: number);
+    _color: RBTNColor;
+    /**
+     * Gets the color of the node (used in Red-Black trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The node's color.
+     */
+    get color(): RBTNColor;
+    /**
+     * Sets the color of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new color.
+     */
+    set color(value: RBTNColor);
+    _count: number;
+    /**
+     * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The subtree node count.
+     */
+    get count(): number;
+    /**
+     * Sets the count of nodes in the subtree.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new count.
+     */
+    set count(value: number);
+    /**
+     * Gets the position of the node relative to its parent.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+     */
+    get familyPosition(): FamilyPosition;
 }
 /**
  * AVL-tree–based multimap (key → array of values). Preserves O(log N) updates and supports map-like mode.
@@ -70,6 +124,14 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<
      */
     constructor(keysNodesEntriesOrRaws?: Iterable<K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | R>, options?: AVLTreeMultiMapOptions<K, V[], R>);
     createNode(key: K, value?: V[]): AVLTreeMultiMapNode<K, V>;
+    /**
+     * Checks if the given item is a `AVLTreeMultiMapNode` instance.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param keyNodeOrEntry - The item to check.
+     * @returns True if it's a AVLTreeMultiMapNode, false otherwise.
+     */
+    isNode(keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): keyNodeOrEntry is AVLTreeMultiMapNode<K, V>;
     add(keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
     add(key: K, value: V): boolean;
     /**

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BST, BSTNode } from './bst';
-import type { AVLTreeOptions, BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, IterationType } from '../../types';
+import { BST } from './bst';
+import type { AVLTreeOptions, BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, FamilyPosition, IterationType, RBTNColor } from '../../types';
 import { BSTOptions } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 /**
@@ -16,7 +16,9 @@ import { IBinaryTree } from '../../interfaces';
  * @template K - The type of the key.
  * @template V - The type of the value.
  */
-export declare class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
+export declare class AVLTreeNode<K = any, V = any> {
+    key: K;
+    value?: V;
     parent?: AVLTreeNode<K, V>;
     /**
      * Creates an instance of AVLTreeNode.
@@ -56,6 +58,58 @@ export declare class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
      * @param v - The node to set as the right child.
      */
     set right(v: AVLTreeNode<K, V> | null | undefined);
+    _height: number;
+    /**
+     * Gets the height of the node (used in self-balancing trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The height.
+     */
+    get height(): number;
+    /**
+     * Sets the height of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new height.
+     */
+    set height(value: number);
+    _color: RBTNColor;
+    /**
+     * Gets the color of the node (used in Red-Black trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The node's color.
+     */
+    get color(): RBTNColor;
+    /**
+     * Sets the color of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new color.
+     */
+    set color(value: RBTNColor);
+    _count: number;
+    /**
+     * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The subtree node count.
+     */
+    get count(): number;
+    /**
+     * Sets the count of nodes in the subtree.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new count.
+     */
+    set count(value: number);
+    /**
+     * Gets the position of the node relative to its parent.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+     */
+    get familyPosition(): FamilyPosition;
 }
 /**
  * Represents a self-balancing AVL (Adelson-Velsky and Landis) Tree.
@@ -71,7 +125,9 @@ export declare class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
  * 4. Order Preservation: Maintains the binary search tree property where left child values are less than the parent, and right child values are greater.
  * 5. Efficient Lookups: Offers O(log n) search time, where 'n' is the number of nodes, due to its balanced nature.
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
- * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.@example
+ * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
+ *
+ * @example
  * // Find elements in a range
  *     // In interval queries, AVL trees, with their strictly balanced structure and lower height, offer better query efficiency, making them ideal for frequent and high-performance interval queries. In contrast, Red-Black trees, with lower update costs, are more suitable for scenarios involving frequent insertions and deletions where the requirements for interval queries are less demanding.
  *     type Datum = { timestamp: Date; temperature: number };
@@ -219,7 +275,7 @@ export declare class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> imp
      * @param [options] - Options for the new tree.
      * @returns A new AVLTree.
      */
-    protected _createLike<TK = K, TV = V, TR = R>(iter?: Iterable<TK | BSTNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<BSTOptions<TK, TV, TR>>): AVLTree<TK, TV, TR>;
+    protected _createLike<TK = K, TV = V, TR = R>(iter?: Iterable<TK | AVLTreeNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<BSTOptions<TK, TV, TR>>): AVLTree<TK, TV, TR>;
     /**
      * (Protected) Swaps properties of two nodes, including height.
      * @remarks Time O(H) (due to `ensureNode`), but O(1) if nodes are passed directly.

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

@@ -123,6 +123,7 @@ export declare class BinaryTreeNode<K = any, V = any> {
  * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
+ *
  * @example
  * // determine loan approval using a decision tree
  *     // Decision tree structure

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeOptions, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparable, Comparator, CP, DFSOrderPattern, EntryCallback, IterationType, NodeCallback, NodePredicate, OptNode } from '../../types';
-import { BinaryTree, BinaryTreeNode } from './binary-tree';
+import type { BinaryTreeOptions, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparable, Comparator, CP, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodePredicate, OptNode, RBTNColor } from '../../types';
+import { BinaryTree } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Range } from '../../common';
 /**
@@ -15,7 +15,9 @@ import { Range } from '../../common';
  * @template K - The type of the key.
  * @template V - The type of the value.
  */
-export declare class BSTNode<K = any, V = any> extends BinaryTreeNode<K, V> {
+export declare class BSTNode<K = any, V = any> {
+    key: K;
+    value?: V;
     parent?: BSTNode<K, V>;
     /**
      * Creates an instance of BSTNode.
@@ -55,6 +57,58 @@ export declare class BSTNode<K = any, V = any> extends BinaryTreeNode<K, V> {
      * @param v - The node to set as the right child.
      */
     set right(v: BSTNode<K, V> | null | undefined);
+    _height: number;
+    /**
+     * Gets the height of the node (used in self-balancing trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The height.
+     */
+    get height(): number;
+    /**
+     * Sets the height of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new height.
+     */
+    set height(value: number);
+    _color: RBTNColor;
+    /**
+     * Gets the color of the node (used in Red-Black trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The node's color.
+     */
+    get color(): RBTNColor;
+    /**
+     * Sets the color of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new color.
+     */
+    set color(value: RBTNColor);
+    _count: number;
+    /**
+     * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The subtree node count.
+     */
+    get count(): number;
+    /**
+     * Sets the count of nodes in the subtree.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new count.
+     */
+    set count(value: number);
+    /**
+     * Gets the position of the node relative to its parent.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+     */
+    get familyPosition(): FamilyPosition;
 }
 /**
  * Represents a Binary Search Tree (BST).
@@ -70,6 +124,7 @@ export declare class BSTNode<K = any, V = any> extends BinaryTreeNode<K, V> {
  * 5. Logarithmic Operations: Ideal operations like insertion, deletion, and searching are O(log n) time-efficient.
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
+ *
  * @example
  * // Merge 3 sorted datasets
  *     const dataset1 = new BST<number, string>([

package/dist/types/data-structures/binary-tree/red-black-tree.d.ts

@@ -5,10 +5,12 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BinaryTreeOptions, CRUD, EntryCallback, RBTNColor, RedBlackTreeOptions } from '../../types';
-import { BST, BSTNode } from './bst';
+import type { BinaryTreeDeleteResult, BinaryTreeOptions, CRUD, EntryCallback, FamilyPosition, RBTNColor, RedBlackTreeOptions } from '../../types';
+import { BST } from './bst';
 import { IBinaryTree } from '../../interfaces';
-export declare class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
+export declare class RedBlackTreeNode<K = any, V = any> {
+    key: K;
+    value?: V;
     parent?: RedBlackTreeNode<K, V>;
     /**
      * Create a Red-Black Tree and optionally bulk-insert items.
@@ -47,6 +49,58 @@ export declare class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
      * @returns void
      */
     set right(v: RedBlackTreeNode<K, V> | null | undefined);
+    _height: number;
+    /**
+     * Gets the height of the node (used in self-balancing trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The height.
+     */
+    get height(): number;
+    /**
+     * Sets the height of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new height.
+     */
+    set height(value: number);
+    _color: RBTNColor;
+    /**
+     * Gets the color of the node (used in Red-Black trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The node's color.
+     */
+    get color(): RBTNColor;
+    /**
+     * Sets the color of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new color.
+     */
+    set color(value: RBTNColor);
+    _count: number;
+    /**
+     * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The subtree node count.
+     */
+    get count(): number;
+    /**
+     * Sets the count of nodes in the subtree.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new count.
+     */
+    set count(value: number);
+    /**
+     * Gets the position of the node relative to its parent.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+     */
+    get familyPosition(): FamilyPosition;
 }
 /**
  * Represents a Red-Black Tree (self-balancing BST) supporting map-like mode and stable O(log n) updates.
@@ -54,8 +108,9 @@ export declare class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
  * @template K
  * @template V
  * @template R
- * 1. Efficient self-balancing, but not completely balanced. Compared with AVLTree, the addition and deletion efficiency is high but the query efficiency is slightly lower.
+ * 1. Efficient self-balancing, but not completely balanced. Compared with AVLTree, the addition and deletion efficiency is high, but the query efficiency is slightly lower.
  * 2. It is BST itself. Compared with Heap which is not completely ordered, RedBlackTree is completely ordered.
+ *
  * @example
  * // using Red-Black Tree as a price-based index for stock data
  *     // Define the structure of individual stock records

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

@@ -5,18 +5,20 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, IterationType, RBTNColor, TreeCounterOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, FamilyPosition, IterationType, RBTNColor, TreeCounterOptions } from '../../types';
 import { BSTOptions } from '../../types';
 import { BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
-import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
+import { RedBlackTree } from './red-black-tree';
 /**
  * RB-tree node with an extra 'count' field; keeps parent/child links.
  * @remarks Time O(1), Space O(1)
  * @template K
  * @template V
  */
-export declare class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
+export declare class TreeCounterNode<K = any, V = any> {
+    key: K;
+    value?: V;
     parent?: TreeCounterNode<K, V>;
     /**
      * Create a tree counter node.
@@ -56,6 +58,58 @@ export declare class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<
      * @returns void
      */
     set right(v: TreeCounterNode<K, V> | null | undefined);
+    _height: number;
+    /**
+     * Gets the height of the node (used in self-balancing trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The height.
+     */
+    get height(): number;
+    /**
+     * Sets the height of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new height.
+     */
+    set height(value: number);
+    _color: RBTNColor;
+    /**
+     * Gets the color of the node (used in Red-Black trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The node's color.
+     */
+    get color(): RBTNColor;
+    /**
+     * Sets the color of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new color.
+     */
+    set color(value: RBTNColor);
+    _count: number;
+    /**
+     * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The subtree node count.
+     */
+    get count(): number;
+    /**
+     * Sets the count of nodes in the subtree.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new count.
+     */
+    set count(value: number);
+    /**
+     * Gets the position of the node relative to its parent.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+     */
+    get familyPosition(): FamilyPosition;
 }
 /**
  * Red-Black Tree–based counter map (key → value with per-node count). Supports O(log N) updates and map-like mode.

package/dist/types/data-structures/binary-tree/tree-multi-map.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElemOf, EntryCallback, RedBlackTreeOptions, TreeMultiMapOptions } from '../../types';
+import type { ElemOf, EntryCallback, FamilyPosition, RBTNColor, RedBlackTreeOptions, TreeMultiMapOptions } from '../../types';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 import { IBinaryTree } from '../../interfaces';
 /**
@@ -14,7 +14,9 @@ import { IBinaryTree } from '../../interfaces';
  * @template K
  * @template V
  */
-export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]> {
+export declare class TreeMultiMapNode<K = any, V = any> {
+    key: K;
+    value?: V[];
     parent?: TreeMultiMapNode<K, V>;
     /**
      * Create a TreeMultiMap node with an optional value bucket.
@@ -23,7 +25,7 @@ export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode
      * @param [value] - Initial array of values.
      * @returns New TreeMultiMapNode instance.
      */
-    constructor(key: K, value?: V[]);
+    constructor(key: K, value?: V[], color?: RBTNColor);
     _left?: TreeMultiMapNode<K, V> | null | undefined;
     /**
      * Get the left child pointer.
@@ -52,6 +54,58 @@ export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode
      * @returns void
      */
     set right(v: TreeMultiMapNode<K, V> | null | undefined);
+    _height: number;
+    /**
+     * Gets the height of the node (used in self-balancing trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The height.
+     */
+    get height(): number;
+    /**
+     * Sets the height of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new height.
+     */
+    set height(value: number);
+    _color: RBTNColor;
+    /**
+     * Gets the color of the node (used in Red-Black trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The node's color.
+     */
+    get color(): RBTNColor;
+    /**
+     * Sets the color of the node.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new color.
+     */
+    set color(value: RBTNColor);
+    _count: number;
+    /**
+     * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The subtree node count.
+     */
+    get count(): number;
+    /**
+     * Sets the count of nodes in the subtree.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param value - The new count.
+     */
+    set count(value: number);
+    /**
+     * Gets the position of the node relative to its parent.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+     */
+    get familyPosition(): FamilyPosition;
 }
 /**
  * Red-Black Tree–based multimap (key → array of values). Preserves O(log N) updates and supports map-like mode.
@@ -59,6 +113,7 @@ export declare class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode
  * @template K
  * @template V
  * @template R
+ *
  * @example
  * // players ranked by score with their equipment
  *     type Equipment = {
@@ -234,6 +289,14 @@ export declare class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTre
      */
     constructor(keysNodesEntriesOrRaws?: Iterable<K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | R>, options?: TreeMultiMapOptions<K, V[], R>);
     createNode(key: K, value?: V[]): TreeMultiMapNode<K, V>;
+    /**
+     * Checks if the given item is a `TreeMultiMapNode` instance.
+     * @remarks Time O(1), Space O(1)
+     *
+     * @param keyNodeOrEntry - The item to check.
+     * @returns True if it's a TreeMultiMapNode, false otherwise.
+     */
+    isNode(keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): keyNodeOrEntry is TreeMultiMapNode<K, V>;
     add(keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
     add(key: K, value: V): boolean;
     /**

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

@@ -1,6 +1,6 @@
 import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
 import { LinearBase } from '../../../data-structures/base/linear-base';
-export type EntryCallback<K, V, R> = (key: K, value: V, index: number, original: IterableEntryBase<K, V>) => R;
+export type EntryCallback<K, V, R> = (value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
 export type ElementCallback<E, R, RT> = (element: E, index: number, original: IterableElementBase<E, R>) => RT;
 export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
 export type ReduceElementCallback<E, R, U = E> = (accumulator: U, value: E, index: number, self: IterableElementBase<E, R>) => U;