data-structure-typed 2.4.5 → 2.5.1

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

@@ -125,84 +125,6 @@ export declare class BinaryTreeNode<K = any, V = any> {
  * 5. Leaf Nodes: Nodes without children are leaves.
  *
  * @example
- * // basic BinaryTree creation and insertion
- *  // Create a BinaryTree with entries
- *     const entries: [number, string][] = [
- *       [6, 'six'],
- *       [1, 'one'],
- *       [2, 'two'],
- *       [7, 'seven'],
- *       [5, 'five'],
- *       [3, 'three'],
- *       [4, 'four'],
- *       [9, 'nine'],
- *       [8, 'eight']
- *     ];
- *
- *     const tree = new BinaryTree(entries);
- *
- *     // Verify size
- *     console.log(tree.size); // 9;
- *
- *     // Add new element
- *     tree.set(10, 'ten');
- *     console.log(tree.size); // 10;
- * @example
- * // BinaryTree get and has operations
- *  const tree = new BinaryTree(
- *       [
- *         [5, 'five'],
- *         [3, 'three'],
- *         [7, 'seven'],
- *         [1, 'one'],
- *         [4, 'four'],
- *         [6, 'six'],
- *         [8, 'eight']
- *       ],
- *       { isMapMode: false }
- *     );
- *
- *     // Check if key exists
- *     console.log(tree.has(5)); // true;
- *     console.log(tree.has(10)); // false;
- *
- *     // Get value by key
- *     console.log(tree.get(3)); // 'three';
- *     console.log(tree.get(7)); // 'seven';
- *     console.log(tree.get(100)); // undefined;
- *
- *     // Get node structure
- *     const node = tree.getNode(5);
- *     console.log(node?.key); // 5;
- *     console.log(node?.value); // 'five';
- * @example
- * // BinaryTree level-order traversal
- *  const tree = new BinaryTree([
- *       [1, 'one'],
- *       [2, 'two'],
- *       [3, 'three'],
- *       [4, 'four'],
- *       [5, 'five'],
- *       [6, 'six'],
- *       [7, 'seven']
- *     ]);
- *
- *     // Binary tree maintains level-order insertion
- *     // Complete binary tree structure
- *     console.log(tree.size); // 7;
- *
- *     // Verify all keys are present
- *     console.log(tree.has(1)); // true;
- *     console.log(tree.has(4)); // true;
- *     console.log(tree.has(7)); // true;
- *
- *     // Iterate through tree
- *     const keys: number[] = [];
- *     for (const [key] of tree) {
- *       keys.push(key);
- *     }
- *     console.log(keys.length); // 7;
- * @example
  * // determine loan approval using a decision tree
  *  // Decision tree structure
  *     const loanDecisionTree = new BinaryTree<string>(
@@ -428,13 +350,47 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param key - The key to validate.
      * @returns True if the key is valid, false otherwise.
      */
-    isValidKey(key: any): key is K;
+    isValidKey(key: unknown): key is K;
     /**
      * Adds a new node to the tree.
      * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation adds the node at the first available position in a level-order (BFS) traversal. This is NOT a Binary Search Tree insertion. Time O(N), where N is the number of nodes. It must traverse level-by-level to find an empty slot. Space O(N) in the worst case for the BFS queue (e.g., a full last level).
      *
      * @param keyNodeOrEntry - The key, node, or entry to add.
      * @returns True if the addition was successful, false otherwise.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Add a single node
+   *  const tree = new BinaryTree<number>();
+   *     tree.add(1);
+   *     tree.add(2);
+   *     tree.add(3);
+   *     console.log(tree.size); // 3;
+   *     console.log(tree.has(1)); // true;
      */
     add(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): boolean;
     /**
@@ -444,6 +400,60 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param keyNodeOrEntry - The key, node, or entry to set or update.
      * @param [value] - The value, if providing just a key.
      * @returns True if the addition was successful, false otherwise.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // basic BinaryTree creation and insertion
+   *  // Create a BinaryTree with entries
+   *     const entries: [number, string][] = [
+   *       [6, 'six'],
+   *       [1, 'one'],
+   *       [2, 'two'],
+   *       [7, 'seven'],
+   *       [5, 'five'],
+   *       [3, 'three'],
+   *       [4, 'four'],
+   *       [9, 'nine'],
+   *       [8, 'eight']
+   *     ];
+   *
+   *     const tree = new BinaryTree(entries);
+   *
+   *     // Verify size
+   *     console.log(tree.size); // 9;
+   *
+   *     // Add new element
+   *     tree.set(10, 'ten');
+   *     console.log(tree.size); // 10;
      */
     set(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
     /**
@@ -452,6 +462,40 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      *
      * @param keysNodesEntriesOrRaws - An iterable of items to set.
      * @returns An array of booleans indicating the success of each individual `set` operation.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Bulk add
+   *  const tree = new BinaryTree<number>();
+   *     tree.addMany([1, 2, 3, 4, 5]);
+   *     console.log(tree.size); // 5;
      */
     addMany(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>): boolean[];
     /**
@@ -461,6 +505,33 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param keysNodesEntriesOrRaws - An iterable of items to set or update.
      * @param [values] - An optional parallel iterable of values.
      * @returns An array of booleans indicating the success of each individual `set` operation.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Set multiple entries
+   *  const tree = new BinaryTree<number, string>();
+   *     tree.setMany([[1, 'a'], [2, 'b'], [3, 'c']]);
+   *     console.log(tree.size); // 3;
      */
     setMany(keysNodesEntriesOrRaws: Iterable<K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, values?: Iterable<V | undefined>): boolean[];
     /**
@@ -468,6 +539,41 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @remarks Time O(N * M), same as `setMany`, where N is the size of `anotherTree` and M is the size of this tree. Space O(M) (from `set`).
      *
      * @param anotherTree - The tree to merge.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Combine trees
+   *  const t1 = new BinaryTree<number>([1, 2]);
+   *     const t2 = new BinaryTree<number>([3, 4]);
+   *     t1.merge(t2);
+   *     console.log(t1.size); // 4;
      */
     merge(anotherTree: BinaryTree<K, V, R>): void;
     /**
@@ -484,8 +590,75 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      *
      * @param keyNodeEntryRawOrPredicate - The node to delete.
      * @returns An array containing deletion results (for compatibility with self-balancing trees).
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Remove a node
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+   *     tree.delete(3);
+   *     console.log(tree.has(3)); // false;
+   *     console.log(tree.size); // 4;
      */
     delete(keyNodeEntryRawOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[];
+    /**
+   * Search by predicate
+  
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Search by predicate
+ *  const tree = new BinaryTree<number>([5, 3, 7, 1, 9]);
+ *     const found = tree.search(n => n!.key > 5, true);
+ *     console.log(found.length); // >= 1;
+   */
     search(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, onlyOne?: boolean): (K | undefined)[];
     search<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, onlyOne: boolean, callback: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
     /**
@@ -497,6 +670,39 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param [startNode=this._root] - The node to start the search from.
      * @param [iterationType=this.iterationType] - The traversal method.
      * @returns An array of matching nodes.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Get nodes by condition
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+   *     const nodes = tree.getNodes(node => node.key > 3);
+   *     console.log(nodes.length); // 2;
      */
     getNodes(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V>>, onlyOne?: boolean, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): BinaryTreeNode<K, V>[];
     /**
@@ -507,6 +713,39 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param [startNode=this._root] - The node to start the search from.
      * @param [iterationType=this.iterationType] - The traversal method.
      * @returns The first matching node, or undefined if not found.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Get node by key
+   *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'child']]);
+   *     console.log(tree.getNode(2)?.value); // 'child';
      */
     getNode(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V> | null>, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): BinaryTreeNode<K, V> | null | undefined;
     /**
@@ -517,6 +756,42 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param [startNode=this._root] - The node to start searching from (if not in Map mode).
      * @param [iterationType=this.iterationType] - The traversal method (if not in Map mode).
      * @returns The associated value, or undefined.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Retrieve value by key
+   *  const tree = new BinaryTree<number, string>([[1, 'root'], [2, 'left'], [3, 'right']]);
+   *     console.log(tree.get(2)); // 'left';
+   *     console.log(tree.get(99)); // undefined;
      */
     get(keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): V | undefined;
     /**
@@ -527,11 +802,104 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param [startNode] - The node to start the search from.
      * @param [iterationType] - The traversal method.
      * @returns True if a matching node exists, false otherwise.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // BinaryTree get and has operations
+   *  const tree = new BinaryTree(
+   *       [
+   *         [5, 'five'],
+   *         [3, 'three'],
+   *         [7, 'seven'],
+   *         [1, 'one'],
+   *         [4, 'four'],
+   *         [6, 'six'],
+   *         [8, 'eight']
+   *       ],
+   *       { isMapMode: false }
+   *     );
+   *
+   *     // Check if key exists
+   *     console.log(tree.has(5)); // true;
+   *     console.log(tree.has(10)); // false;
+   *
+   *     // Get value by key
+   *     console.log(tree.get(3)); // 'three';
+   *     console.log(tree.get(7)); // 'seven';
+   *     console.log(tree.get(100)); // undefined;
+   *
+   *     // Get node structure
+   *     const node = tree.getNode(5);
+   *     console.log(node?.key); // 5;
+   *     console.log(node?.value); // 'five';
      */
     has(keyNodeEntryOrPredicate?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | NodePredicate<BinaryTreeNode<K, V>>, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): boolean;
     /**
      * Clears the tree of all nodes and values.
      * @remarks Time O(N) if in Map mode (due to `_store.clear()`), O(1) otherwise. Space O(1)
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Remove all nodes
+   *  const tree = new BinaryTree<number>([1, 2, 3]);
+   *     tree.clear();
+   *     console.log(tree.isEmpty()); // true;
      */
     clear(): void;
     /**
@@ -539,6 +907,38 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @remarks Time O(1), Space O(1)
      *
      * @returns True if the tree has no nodes, false otherwise.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Check empty
+   *  console.log(new BinaryTree().isEmpty()); // true;
      */
     isEmpty(): boolean;
     /**
@@ -556,6 +956,40 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param [startNode=this._root] - The node to start checking from.
      * @param [iterationType=this.iterationType] - The traversal method.
      * @returns True if it's a valid BST, false otherwise.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Check BST property
+   *  const tree = new BinaryTree<number>([1, 2, 3]);
+   *     // BinaryTree doesn't guarantee BST order
+   *     console.log(typeof tree.isBST()); // 'boolean';
      */
     isBST(startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): boolean;
     /**
@@ -565,6 +999,42 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param dist - The node to find the depth of.
      * @param [startNode=this._root] - The node to measure depth from (defaults to root).
      * @returns The depth (0 if `dist` is `startNode`).
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Get depth of a node
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+   *     const node = tree.getNode(4);
+   *     console.log(tree.getDepth(node!)); // 2;
      */
     getDepth(dist: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): number;
     /**
@@ -574,6 +1044,41 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param [startNode=this._root] - The node to start measuring from.
      * @param [iterationType=this.iterationType] - The traversal method.
      * @returns The height ( -1 for an empty tree, 0 for a single-node tree).
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Get tree height
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+   *     console.log(tree.getHeight()); // 2;
      */
     getHeight(startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): number;
     /**
@@ -607,17 +1112,227 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @returns The successor node, or null/undefined if none exists.
      */
     getSuccessor(x?: K | BinaryTreeNode<K, V> | null): BinaryTreeNode<K, V> | null | undefined;
+    /**
+   * Depth-first search traversal
+  
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Depth-first search traversal
+ *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+ *     const inOrder = tree.dfs(node => node.key, 'IN');
+ *     console.log(inOrder); // [4, 2, 5, 1, 3];
+   */
     dfs(): (K | undefined)[];
     dfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, pattern?: DFSOrderPattern, onlyOne?: boolean, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
     dfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, pattern?: DFSOrderPattern, onlyOne?: boolean, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: boolean): ReturnType<C>[];
+    /**
+   * BinaryTree level-order traversal
+  
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // BinaryTree level-order traversal
+ *  const tree = new BinaryTree([
+ *       [1, 'one'],
+ *       [2, 'two'],
+ *       [3, 'three'],
+ *       [4, 'four'],
+ *       [5, 'five'],
+ *       [6, 'six'],
+ *       [7, 'seven']
+ *     ]);
+ *
+ *     // Binary tree maintains level-order insertion
+ *     // Complete binary tree structure
+ *     console.log(tree.size); // 7;
+ *
+ *     // Verify all keys are present
+ *     console.log(tree.has(1)); // true;
+ *     console.log(tree.has(4)); // true;
+ *     console.log(tree.has(7)); // true;
+ *
+ *     // Iterate through tree
+ *     const keys: number[] = [];
+ *     for (const [key] of tree) {
+ *       keys.push(key);
+ *     }
+ *     console.log(keys.length); // 7;
+   */
     bfs(): (K | undefined)[];
     bfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
     bfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    /**
+   * Get leaf nodes
+  
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Get leaf nodes
+ *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+ *     const leafKeys = tree.leaves(node => node.key);
+ *     console.log(leafKeys.length); // > 0;
+   */
     leaves(): (K | undefined)[];
     leaves<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType): ReturnType<C>[];
+    /**
+   * Level-order grouping
+  
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Level-order grouping
+ *  const tree = new BinaryTree<number>([1, 2, 3, 4, 5]);
+ *     const levels = tree.listLevels(node => node.key);
+ *     console.log(levels[0]); // [1];
+ *     console.log(levels[1].sort()); // [2, 3];
+   */
     listLevels(): (K | undefined)[][];
     listLevels<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
     listLevels<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(callback?: C, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    /**
+   * Morris traversal (O(1) space)
+  
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Morris traversal (O(1) space)
+ *  const tree = new BinaryTree<number>([1, 2, 3]);
+ *     const result = tree.morris(node => node.key, 'IN');
+ *     console.log(result.length); // 3;
+   */
     morris(): (K | undefined)[];
     morris<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback?: C, pattern?: DFSOrderPattern, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): ReturnType<C>[];
     /**
@@ -625,6 +1340,41 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @remarks Time O(N * M), where N is the number of nodes and M is the tree size during insertion (due to `bfs` + `set`, and `set` is O(M)). Space O(N) for the new tree and the BFS queue.
      *
      * @returns A new, cloned instance of the tree.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Deep copy
+   *  const tree = new BinaryTree<number>([1, 2, 3]);
+   *     const copy = tree.clone();
+   *     copy.delete(1);
+   *     console.log(tree.has(1)); // true;
      */
     clone(): this;
     /**
@@ -634,6 +1384,40 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param predicate - A function to test each [key, value] pair.
      * @param [thisArg] - `this` context for the predicate.
      * @returns A new, filtered tree.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Filter nodes by condition
+   *  const tree = new BinaryTree<number>([1, 2, 3, 4]);
+   *     const result = tree.filter((_, key) => key > 2);
+   *     console.log(result.size); // 2;
      */
     filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: unknown): this;
     /**
@@ -647,6 +1431,40 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param [options] - Options for the new tree.
      * @param [thisArg] - `this` context for the callback.
      * @returns A new, mapped tree.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Transform to new tree
+   *  const tree = new BinaryTree<number, number>([[1, 10], [2, 20]]);
+   *     const mapped = tree.map((v, key) => [key, (v ?? 0) + 1] as [number, number]);
+   *     console.log([...mapped.values()]); // contains 11;
      */
     map<MK = K, MV = V, MR = any>(cb: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BinaryTreeOptions<MK, MV, MR>>, thisArg?: unknown): BinaryTree<MK, MV, MR>;
     /**
@@ -664,6 +1482,39 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      *
      * @param [options] - Options to control the output.
      * @param [startNode=this._root] - The node to start printing from.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Display tree
+   *  const tree = new BinaryTree<number>([1, 2, 3]);
+   *     expect(() => tree.print()).not.toThrow();
      */
     print(options?: BinaryTreePrintOptions, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): void;
     protected _dfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(callback: C, pattern?: DFSOrderPattern, onlyOne?: boolean, startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, iterationType?: IterationType, includeNull?: boolean, shouldVisitLeft?: (node: BinaryTreeNode<K, V> | null | undefined) => boolean, shouldVisitRight?: (node: BinaryTreeNode<K, V> | null | undefined) => boolean, shouldVisitRoot?: (node: BinaryTreeNode<K, V> | null | undefined) => boolean, shouldProcessRoot?: (node: BinaryTreeNode<K, V> | null | undefined) => boolean): ReturnType<C>[];
@@ -785,7 +1636,7 @@ export declare class BinaryTree<K = any, V = any, R = any> extends IterableEntry
      * @param p - The item to check.
      * @returns True if it's a function.
      */
-    protected _isPredicate(p: any): p is NodePredicate<BinaryTreeNode<K, V>>;
+    protected _isPredicate(p: unknown): p is NodePredicate<BinaryTreeNode<K, V>>;
     /**
      * (Protected) Extracts the key from a key, node, or entry.
      * @remarks Time O(1)