data-structure-typed 2.0.5 → 2.1.1

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

@@ -1,104 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Pablo Zeng
- * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import { AVLTreeMultiMapOptions } from '../../types';
-import { AVLTree, AVLTreeNode } from './avl-tree';
-import { IBinaryTree } from '../../interfaces';
-export declare class AVLTreeMultiMapNode<K = any, V = any> extends AVLTreeNode<K, V[]> {
-    parent?: AVLTreeMultiMapNode<K, V>;
-    /**
-     * This TypeScript constructor initializes an object with a key of type K and an array of values of
-     * type V.
-     * @param {K} key - The `key` parameter is typically used to store a unique identifier or key for the
-     * data being stored in the data structure. It helps in quickly accessing or retrieving the
-     * associated value in the data structure.
-     * @param {V[]} value - The `value` parameter in the constructor represents an array of values of
-     * type `V`.
-     */
-    constructor(key: K, value: V[]);
-    _left?: AVLTreeMultiMapNode<K, V> | null | undefined;
-    get left(): AVLTreeMultiMapNode<K, V> | null | undefined;
-    set left(v: AVLTreeMultiMapNode<K, V> | null | undefined);
-    _right?: AVLTreeMultiMapNode<K, V> | null | undefined;
-    get right(): AVLTreeMultiMapNode<K, V> | null | undefined;
-    set right(v: AVLTreeMultiMapNode<K, V> | null | undefined);
-}
-/**
- *
- */
-export declare class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR = object> extends AVLTree<K, V[], R, MK, MV[], MR> implements IBinaryTree<K, V[], R, MK, MV, MR> {
-    /**
-     * The constructor initializes an AVLTreeMultiMap with the provided keys, nodes, entries, or raw data
-     * and options.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-     * iterable that can contain either key-value pairs represented as `BTNRep<K, V[],
-     * AVLTreeMultiMapNode<K, V>>` or raw data represented as `R`. This parameter is used to initialize
-     * the AVLTreeMulti
-     * @param [options] - The `options` parameter in the constructor is of type
-     * `AVLTreeMultiMapOptions<K, V[], R>`. It is an optional parameter that allows you to specify
-     * additional options for configuring the AVLTreeMultiMap instance.
-     */
-    constructor(keysNodesEntriesOrRaws?: Iterable<K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | R>, options?: AVLTreeMultiMapOptions<K, V[], R>);
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function `createTree` in TypeScript overrides the creation of an AVLTreeMultiMap with
-     * specified options.
-     * @param [options] - The `options` parameter in the `createTree` function is of type
-     * `AVLTreeMultiMapOptions<K, V[], R>`. This means it is an object that can have properties of type
-     * `K`, `V[]`, and `R`. The function creates a new `AVL
-     * @returns The `createTree` method is returning a new instance of `AVLTreeMultiMap` with the
-     * provided options.
-     */
-    createTree(options?: AVLTreeMultiMapOptions<K, V[], R>): AVLTreeMultiMap<K, V, R, MK, MV, MR>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `createNode` function in TypeScript overrides the default implementation to create a new
-     * AVLTreeMultiMapNode with a specified key and value array.
-     * @param {K} key - The `key` parameter represents the key of the node being created in the
-     * AVLTreeMultiMap.
-     * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
-     * values associated with a specific key in the AVLTreeMultiMapNode. If no value is provided when
-     * calling the method, an empty array `[]` is used as the default value.
-     * @returns An AVLTreeMultiMapNode object is being returned, with the specified key and value. If the
-     * AVLTreeMultiMap is in map mode, an empty array is used as the value, otherwise the provided value
-     * array is used.
-     */
-    createNode(key: K, value?: V[]): AVLTreeMultiMapNode<K, V>;
-    add(keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
-    add(key: K, value: V): boolean;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     *
-     * The function `deleteValue` removes a specific value from a key in an AVLTreeMultiMap data
-     * structure and deletes the entire node if no values are left for that key.
-     * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `deleteValue` function can be either a `BTNRep` object representing a key-value
-     * pair in the AVLTreeMultiMapNode, or just the key itself.
-     * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
-     * value that you want to delete from the multi-map data structure associated with a particular key.
-     * The function checks if the value exists in the array of values associated with the key, and if
-     * found, removes it from the array.
-     * @returns The `deleteValue` function returns a boolean value. It returns `true` if the specified
-     * `value` was successfully deleted from the array of values associated with the `keyNodeOrEntry`. If
-     * the value was not found in the array, it returns `false`.
-     */
-    deleteValue(keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K, value: V): boolean;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
-     * structure.
-     * @returns A cloned tree object is being returned.
-     */
-    clone(): AVLTreeMultiMap<K, V, R, MK, MV, MR>;
-}

package/dist/esm/data-structures/binary-tree/avl-tree-multi-map.js

@@ -1,205 +0,0 @@
-import { AVLTree, AVLTreeNode } from './avl-tree';
-export class AVLTreeMultiMapNode extends AVLTreeNode {
-    parent = undefined;
-    /**
-     * This TypeScript constructor initializes an object with a key of type K and an array of values of
-     * type V.
-     * @param {K} key - The `key` parameter is typically used to store a unique identifier or key for the
-     * data being stored in the data structure. It helps in quickly accessing or retrieving the
-     * associated value in the data structure.
-     * @param {V[]} value - The `value` parameter in the constructor represents an array of values of
-     * type `V`.
-     */
-    constructor(key, value) {
-        super(key, value);
-    }
-    _left = undefined;
-    get left() {
-        return this._left;
-    }
-    set left(v) {
-        if (v) {
-            v.parent = this;
-        }
-        this._left = v;
-    }
-    _right = undefined;
-    get right() {
-        return this._right;
-    }
-    set right(v) {
-        if (v) {
-            v.parent = this;
-        }
-        this._right = v;
-    }
-}
-/**
- *
- */
-export class AVLTreeMultiMap extends AVLTree {
-    /**
-     * The constructor initializes an AVLTreeMultiMap with the provided keys, nodes, entries, or raw data
-     * and options.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-     * iterable that can contain either key-value pairs represented as `BTNRep<K, V[],
-     * AVLTreeMultiMapNode<K, V>>` or raw data represented as `R`. This parameter is used to initialize
-     * the AVLTreeMulti
-     * @param [options] - The `options` parameter in the constructor is of type
-     * `AVLTreeMultiMapOptions<K, V[], R>`. It is an optional parameter that allows you to specify
-     * additional options for configuring the AVLTreeMultiMap instance.
-     */
-    constructor(keysNodesEntriesOrRaws = [], options) {
-        super([], { ...options, isMapMode: true });
-        if (keysNodesEntriesOrRaws) {
-            this.addMany(keysNodesEntriesOrRaws);
-        }
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function `createTree` in TypeScript overrides the creation of an AVLTreeMultiMap with
-     * specified options.
-     * @param [options] - The `options` parameter in the `createTree` function is of type
-     * `AVLTreeMultiMapOptions<K, V[], R>`. This means it is an object that can have properties of type
-     * `K`, `V[]`, and `R`. The function creates a new `AVL
-     * @returns The `createTree` method is returning a new instance of `AVLTreeMultiMap` with the
-     * provided options.
-     */
-    createTree(options) {
-        return new AVLTreeMultiMap([], {
-            iterationType: this.iterationType,
-            specifyComparable: this._specifyComparable,
-            toEntryFn: this._toEntryFn,
-            isReverse: this._isReverse,
-            isMapMode: this._isMapMode,
-            ...options
-        });
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `createNode` function in TypeScript overrides the default implementation to create a new
-     * AVLTreeMultiMapNode with a specified key and value array.
-     * @param {K} key - The `key` parameter represents the key of the node being created in the
-     * AVLTreeMultiMap.
-     * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
-     * values associated with a specific key in the AVLTreeMultiMapNode. If no value is provided when
-     * calling the method, an empty array `[]` is used as the default value.
-     * @returns An AVLTreeMultiMapNode object is being returned, with the specified key and value. If the
-     * AVLTreeMultiMap is in map mode, an empty array is used as the value, otherwise the provided value
-     * array is used.
-     */
-    createNode(key, value = []) {
-        return new AVLTreeMultiMapNode(key, this._isMapMode ? [] : value);
-    }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     *
-     * The function `add` in this TypeScript code overrides the superclass method to add key-value pairs
-     * to an AVLTreeMultiMap, handling different input types and scenarios.
-     * @param [key] - The `key` parameter in the `override add` method represents the key of the entry to
-     * be added to the AVLTreeMultiMap. It can be of type `K`, which is the key type of the map. The key
-     * can be a single key value, a node of the AVLTree
-     * @param {V[]} [values] - The `values` parameter in the `add` method represents an array of values
-     * that you want to add to the AVLTreeMultiMap. It can contain one or more values associated with a
-     * specific key.
-     * @returns The `add` method is returning a boolean value, which indicates whether the operation was
-     * successful or not.
-     */
-    add(keyNodeOrEntry, value) {
-        if (this.isRealNode(keyNodeOrEntry))
-            return super.add(keyNodeOrEntry);
-        const _commonAdd = (key, values) => {
-            if (key === undefined || key === null)
-                return false;
-            const _addToValues = () => {
-                const existingValues = this.get(key);
-                if (existingValues !== undefined && values !== undefined) {
-                    for (const value of values)
-                        existingValues.push(value);
-                    return true;
-                }
-                return false;
-            };
-            const _addByNode = () => {
-                const existingNode = this.getNode(key);
-                if (this.isRealNode(existingNode)) {
-                    const existingValues = this.get(existingNode);
-                    if (existingValues === undefined) {
-                        super.add(key, values);
-                        return true;
-                    }
-                    if (values !== undefined) {
-                        for (const value of values)
-                            existingValues.push(value);
-                        return true;
-                    }
-                    else {
-                        return false;
-                    }
-                }
-                else {
-                    return super.add(key, values);
-                }
-            };
-            if (this._isMapMode) {
-                return _addByNode() || _addToValues();
-            }
-            return _addToValues() || _addByNode();
-        };
-        if (this.isEntry(keyNodeOrEntry)) {
-            const [key, values] = keyNodeOrEntry;
-            return _commonAdd(key, value !== undefined ? [value] : values);
-        }
-        return _commonAdd(keyNodeOrEntry, value !== undefined ? [value] : undefined);
-    }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     *
-     * The function `deleteValue` removes a specific value from a key in an AVLTreeMultiMap data
-     * structure and deletes the entire node if no values are left for that key.
-     * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `deleteValue` function can be either a `BTNRep` object representing a key-value
-     * pair in the AVLTreeMultiMapNode, or just the key itself.
-     * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
-     * value that you want to delete from the multi-map data structure associated with a particular key.
-     * The function checks if the value exists in the array of values associated with the key, and if
-     * found, removes it from the array.
-     * @returns The `deleteValue` function returns a boolean value. It returns `true` if the specified
-     * `value` was successfully deleted from the array of values associated with the `keyNodeOrEntry`. If
-     * the value was not found in the array, it returns `false`.
-     */
-    deleteValue(keyNodeOrEntry, value) {
-        const values = this.get(keyNodeOrEntry);
-        if (Array.isArray(values)) {
-            const index = values.indexOf(value);
-            if (index === -1)
-                return false;
-            values.splice(index, 1);
-            // If no values left, remove the entire node
-            if (values.length === 0)
-                this.delete(keyNodeOrEntry);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
-     * structure.
-     * @returns A cloned tree object is being returned.
-     */
-    clone() {
-        const cloned = this.createTree();
-        this._clone(cloned);
-        return cloned;
-    }
-}
-//# sourceMappingURL=avl-tree-multi-map.js.map

package/dist/esm/data-structures/binary-tree/avl-tree-multi-map.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"avl-tree-multi-map.js","sourceRoot":"","sources":["../../../../src/data-structures/binary-tree/avl-tree-multi-map.ts"],"names":[],"mappings":"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"}

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

@@ -1,302 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Pablo Zeng
- * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import { BST, BSTNode } from './bst';
-import type { AVLTreeOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, EntryCallback } from '../../types';
-import { IBinaryTree } from '../../interfaces';
-export declare class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
-    parent?: AVLTreeNode<K, V>;
-    /**
-     * This TypeScript constructor function initializes an instance with a key and an optional value.
-     * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
-     * within a data structure. It serves as a reference or identifier for accessing or manipulating the
-     * associated value or data.
-     * @param {V} [value] - The `value` parameter in the constructor is optional, meaning it does not
-     * have to be provided when creating an instance of the class. If a value is not provided, it will
-     * default to `undefined`.
-     */
-    constructor(key: K, value?: V);
-    _left?: AVLTreeNode<K, V> | null | undefined;
-    get left(): AVLTreeNode<K, V> | null | undefined;
-    set left(v: AVLTreeNode<K, V> | null | undefined);
-    _right?: AVLTreeNode<K, V> | null | undefined;
-    get right(): AVLTreeNode<K, V> | null | undefined;
-    set right(v: AVLTreeNode<K, V> | null | undefined);
-}
-/**
- * 1. Height-Balanced: Each node's left and right subtrees differ in height by no more than one.
- * 2. Automatic Rebalancing: AVL trees rebalance themselves automatically during insertions and deletions.
- * 3. Rotations for Balancing: Utilizes rotations (single or double) to maintain balance after updates.
- * 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
- * // 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 };
- *     // Fixed dataset of CPU temperature readings
- *     const cpuData: Datum[] = [
- *       { timestamp: new Date('2024-12-02T00:00:00'), temperature: 55.1 },
- *       { timestamp: new Date('2024-12-02T00:01:00'), temperature: 56.3 },
- *       { timestamp: new Date('2024-12-02T00:02:00'), temperature: 54.8 },
- *       { timestamp: new Date('2024-12-02T00:03:00'), temperature: 57.2 },
- *       { timestamp: new Date('2024-12-02T00:04:00'), temperature: 58.0 },
- *       { timestamp: new Date('2024-12-02T00:05:00'), temperature: 59.4 },
- *       { timestamp: new Date('2024-12-02T00:06:00'), temperature: 60.1 },
- *       { timestamp: new Date('2024-12-02T00:07:00'), temperature: 61.3 },
- *       { timestamp: new Date('2024-12-02T00:08:00'), temperature: 62.0 },
- *       { timestamp: new Date('2024-12-02T00:09:00'), temperature: 63.5 },
- *       { timestamp: new Date('2024-12-02T00:10:00'), temperature: 64.0 },
- *       { timestamp: new Date('2024-12-02T00:11:00'), temperature: 62.8 },
- *       { timestamp: new Date('2024-12-02T00:12:00'), temperature: 61.5 },
- *       { timestamp: new Date('2024-12-02T00:13:00'), temperature: 60.2 },
- *       { timestamp: new Date('2024-12-02T00:14:00'), temperature: 59.8 },
- *       { timestamp: new Date('2024-12-02T00:15:00'), temperature: 58.6 },
- *       { timestamp: new Date('2024-12-02T00:16:00'), temperature: 57.4 },
- *       { timestamp: new Date('2024-12-02T00:17:00'), temperature: 56.2 },
- *       { timestamp: new Date('2024-12-02T00:18:00'), temperature: 55.7 },
- *       { timestamp: new Date('2024-12-02T00:19:00'), temperature: 54.5 },
- *       { timestamp: new Date('2024-12-02T00:20:00'), temperature: 53.2 },
- *       { timestamp: new Date('2024-12-02T00:21:00'), temperature: 52.8 },
- *       { timestamp: new Date('2024-12-02T00:22:00'), temperature: 51.9 },
- *       { timestamp: new Date('2024-12-02T00:23:00'), temperature: 50.5 },
- *       { timestamp: new Date('2024-12-02T00:24:00'), temperature: 49.8 },
- *       { timestamp: new Date('2024-12-02T00:25:00'), temperature: 48.7 },
- *       { timestamp: new Date('2024-12-02T00:26:00'), temperature: 47.5 },
- *       { timestamp: new Date('2024-12-02T00:27:00'), temperature: 46.3 },
- *       { timestamp: new Date('2024-12-02T00:28:00'), temperature: 45.9 },
- *       { timestamp: new Date('2024-12-02T00:29:00'), temperature: 45.0 }
- *     ];
- *
- *     // Create an AVL tree to store CPU temperature data
- *     const cpuTemperatureTree = new AVLTree<Date, number, Datum>(cpuData, {
- *       toEntryFn: ({ timestamp, temperature }) => [timestamp, temperature]
- *     });
- *
- *     // Query a specific time range (e.g., from 00:05 to 00:15)
- *     const rangeStart = new Date('2024-12-02T00:05:00');
- *     const rangeEnd = new Date('2024-12-02T00:15:00');
- *     const rangeResults = cpuTemperatureTree.rangeSearch([rangeStart, rangeEnd], node => ({
- *       minute: node ? node.key.getMinutes() : 0,
- *       temperature: cpuTemperatureTree.get(node ? node.key : undefined)
- *     }));
- *
- *     console.log(rangeResults); // [
- *  //      { minute: 5, temperature: 59.4 },
- *  //      { minute: 6, temperature: 60.1 },
- *  //      { minute: 7, temperature: 61.3 },
- *  //      { minute: 8, temperature: 62 },
- *  //      { minute: 9, temperature: 63.5 },
- *  //      { minute: 10, temperature: 64 },
- *  //      { minute: 11, temperature: 62.8 },
- *  //      { minute: 12, temperature: 61.5 },
- *  //      { minute: 13, temperature: 60.2 },
- *  //      { minute: 14, temperature: 59.8 },
- *  //      { minute: 15, temperature: 58.6 }
- *  //    ]
- */
-export declare class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = object> extends BST<K, V, R, MK, MV, MR> implements IBinaryTree<K, V, R, MK, MV, MR> {
-    /**
-     * This TypeScript constructor initializes an AVLTree with keys, nodes, entries, or raw data provided
-     * in an iterable format.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-     * iterable that can contain either `
-     K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined ` objects or `R` objects. It is
-     * used to initialize the AVLTree with key-value pairs or raw data entries. If provided
-     * @param [options] - The `options` parameter in the constructor is of type `AVLTreeOptions<K, V,
-     * R>`. It is an optional parameter that allows you to specify additional options for configuring the
-     * AVL tree. These options could include things like custom comparators, initial capacity, or any
-     * other configuration settings specific
-     */
-    constructor(keysNodesEntriesOrRaws?: Iterable<K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, options?: AVLTreeOptions<K, V, R>);
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function creates a new AVL tree node with the given key and value.
-     * @param {K} key - The key parameter is of type K, which represents the key of the node being
-     * created.
-     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
-     * value associated with the key in the node being created.
-     * @returns The method is returning a new instance of the AVLTreeNode class, casted as the generic
-     * type AVLTreeNode<K, V>.
-     */
-    createNode(key: K, value?: V): AVLTreeNode<K, V>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function creates a new AVL tree with the specified options and returns it.
-     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
-     * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
-     * being created.
-     * @returns a new AVLTree object.
-     */
-    createTree(options?: AVLTreeOptions<K, V, R>): AVLTree<K, V, R, MK, MV, MR>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function checks if the input is an instance of AVLTreeNode.
-     * @param {K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `R` or `
-     K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `.
-     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
-     * an instance of the `AVLTreeNode` class.
-     */
-    isNode(keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): keyNodeOrEntry is AVLTreeNode<K, V>;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     *
-     * The function overrides the add method of a class and inserts a key-value pair into a data
-     * structure, then balances the path.
-     * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can accept values of type `R`, `
-     K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `
-     * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
-     * the key or node being added to the data structure.
-     * @returns The method is returning a boolean value.
-     */
-    add(keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V): boolean;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     *
-     * The function overrides the delete method in a TypeScript class, performs deletion, and then
-     * balances the tree if necessary.
-     * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `override delete` method can be one of the following types:
-     * @returns The `delete` method is being overridden in this code snippet. It first calls the `delete`
-     * method from the superclass (presumably a parent class) with the provided `predicate`, which could
-     * be a key, node, entry, or a custom predicate. The result of this deletion operation is stored in
-     * `deletedResults`, which is an array of `BinaryTreeDeleteResult` objects.
-     */
-    delete(keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): BinaryTreeDeleteResult<AVLTreeNode<K, V>>[];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function in TypeScript overrides the default map behavior of an AVLTree data structure
-     * by applying a callback function to each entry and creating a new AVLTree with the results.
-     * @param callback - A function that will be called for each entry in the AVLTree. It takes four
-     * arguments: the key, the value (which can be undefined), the index of the entry, and a reference to
-     * the AVLTree itself.
-     * @param [options] - The `options` parameter in the `override map` function is of type
-     * `AVLTreeOptions<MK, MV, MR>`. It is an optional parameter that allows you to specify additional
-     * options for the AVL tree being created during the mapping process. These options could include
-     * custom comparators, initial
-     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
-     * the value of `this` when executing the `callback` function. It allows you to set the context
-     * (value of `this`) within the callback function. This can be useful when you want to access
-     * properties or
-     * @returns The `map` method is returning a new AVLTree instance (`newTree`) with the entries
-     * modified by the provided callback function.
-     */
-    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: AVLTreeOptions<MK, MV, MR>, thisArg?: any): AVLTree<MK, MV, MR>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
-     * structure.
-     * @returns A cloned tree object is being returned.
-     */
-    clone(): AVLTree<K, V, R, MK, MV, MR>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a
-     * binary search tree.
-     * @param {BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>} srcNode - The `srcNode` parameter represents either a node
-     * object (`AVLTreeNode<K, V>`) or a key-value pair (`R`) that is being swapped with another node.
-     * @param {BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>} destNode - The `destNode` parameter is either an instance of
-     * `R` or an instance of `BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>`.
-     * @returns The method is returning the `destNodeEnsured` object if both `srcNodeEnsured` and
-     * `destNodeEnsured` are truthy. Otherwise, it returns `undefined`.
-     */
-    protected _swapProperties(srcNode: BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>, destNode: BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>): AVLTreeNode<K, V> | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function calculates the balance factor of a node in a binary tree.
-     * @param {AVLTreeNode<K, V>} node - The parameter "node" is of type "AVLTreeNode<K, V>", which likely represents a node in a
-     * binary tree data structure.
-     * @returns the balance factor of a given node. The balance factor is calculated by subtracting the
-     * height of the left subtree from the height of the right subtree.
-     */
-    protected _balanceFactor(node: AVLTreeNode<K, V>): number;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function updates the height of a node in a binary tree based on the heights of its left and
-     * right children.
-     * @param {AVLTreeNode<K, V>} node - The parameter "node" represents a node in a binary tree data structure.
-     */
-    protected _updateHeight(node: AVLTreeNode<K, V>): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `_balanceLL` function performs a left-left rotation to balance a binary search tree.
-     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
-     */
-    protected _balanceLL(A: AVLTreeNode<K, V>): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
-     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
-     */
-    protected _balanceLR(A: AVLTreeNode<K, V>): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
-     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
-     */
-    protected _balanceRR(A: AVLTreeNode<K, V>): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
-     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
-     */
-    protected _balanceRL(A: AVLTreeNode<K, V>): void;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
-     * to restore balance in an AVL tree after inserting a node.
-     * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } node - The `node` parameter can be of type `R` or
-     * `
-     K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `.
-     */
-    protected _balancePath(node: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function replaces an old node with a new node and sets the height of the new node to be the
-     * same as the old node.
-     * @param {AVLTreeNode<K, V>} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
-     * the data structure.
-     * @param {AVLTreeNode<K, V>} newNode - The `newNode` parameter is the new node that will replace the `oldNode` in
-     * the data structure.
-     * @returns The method is returning the result of calling the `_replaceNode` method from the
-     * superclass, with the `oldNode` and `newNode` as arguments.
-     */
-    protected _replaceNode(oldNode: AVLTreeNode<K, V>, newNode: AVLTreeNode<K, V>): AVLTreeNode<K, V>;
-}