data-structure-typed 1.37.9 → 1.38.1

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

@@ -14,12 +14,6 @@ import { IBinaryTree } from '../../interfaces';
  * @template FAMILY - The type of the family relationship in the binary tree.
  */
 export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FAMILY> = BinaryTreeNodeNested<V>> {
-    /**
-     * Creates a new instance of BinaryTreeNode.
-     * @param {BinaryTreeNodeKey} key - The key associated with the node.
-     * @param {V} val - The value stored in the node.
-     */
-    constructor(key: BinaryTreeNodeKey, val?: V);
     /**
      * The key associated with the node.
      */
@@ -28,6 +22,16 @@ export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FA
      * The value stored in the node.
      */
     val: V | undefined;
+    /**
+     * The parent node of the current node.
+     */
+    parent: FAMILY | null | undefined;
+    /**
+     * Creates a new instance of BinaryTreeNode.
+     * @param {BinaryTreeNodeKey} key - The key associated with the node.
+     * @param {V} val - The value stored in the node.
+     */
+    constructor(key: BinaryTreeNodeKey, val?: V);
     private _left;
     /**
      * Get the left child node.
@@ -48,10 +52,6 @@ export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FA
      * @param {FAMILY | null | undefined} v - The right child node.
      */
     set right(v: FAMILY | null | undefined);
-    /**
-     * The parent node of the current node.
-     */
-    parent: FAMILY | null | undefined;
     /**
      * Get the position of the node within its family.
      * @returns {FamilyPosition} - The family position of the node.
@@ -63,18 +63,12 @@ export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FA
  * @template N - The type of the binary tree's nodes.
  */
 export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> implements IBinaryTree<N> {
+    private _loopType;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options?: BinaryTreeOptions);
-    /**
-     * Creates a new instance of BinaryTreeNode with the given key and value.
-     * @param {BinaryTreeNodeKey} key - The key for the new node.
-     * @param {N['val']} val - The value for the new node.
-     * @returns {N} - The newly created BinaryTreeNode.
-     */
-    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     private _root;
     /**
      * Get the root node of the binary tree.
@@ -85,7 +79,6 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * Get the number of nodes in the binary tree.
      */
     get size(): number;
-    private _loopType;
     /**
      * Get the iteration type used in the binary tree.
      */
@@ -96,12 +89,12 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      */
     set iterationType(v: IterationType);
     /**
-     * Swap the data of two nodes in the binary tree.
-     * @param {N} srcNode - The source node to swap.
-     * @param {N} destNode - The destination node to swap.
-     * @returns {N} - The destination node after the swap.
+     * Creates a new instance of BinaryTreeNode with the given key and value.
+     * @param {BinaryTreeNodeKey} key - The key for the new node.
+     * @param {N['val']} val - The value for the new node.
+     * @returns {N} - The newly created BinaryTreeNode.
      */
-    protected _swap(srcNode: N, destNode: N): N;
+    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     /**
      * Clear the binary tree, removing all nodes.
      */
@@ -174,7 +167,6 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @returns the height of the binary tree.
      */
     getHeight(beginRoot?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): number;
-    protected _defaultCallbackByKey: MapCallback<N>;
     /**
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
@@ -359,13 +351,6 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @returns The function `getPredecessor` returns the predecessor node of the given node `node`.
      */
     getPredecessor(node: N): N;
-    /**
-     * Time complexity is O(n)
-     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-     * the tree's structure should be restored to its original state to maintain the tree's integrity.
-     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
-     */
     /**
      * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
      * algorithm and returns an array of values obtained by applying a callback function to each node.
@@ -381,6 +366,21 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @returns The `morris` function returns an array of `MapCallbackReturn<N>` values.
      */
     morris(callback?: MapCallback<N>, pattern?: DFSOrderPattern, beginRoot?: N | null): MapCallbackReturn<N>[];
+    /**
+     * Swap the data of two nodes in the binary tree.
+     * @param {N} srcNode - The source node to swap.
+     * @param {N} destNode - The destination node to swap.
+     * @returns {N} - The destination node after the swap.
+     */
+    protected _swap(srcNode: N, destNode: N): N;
+    /**
+     * Time complexity is O(n)
+     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
+     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
+     * the tree's structure should be restored to its original state to maintain the tree's integrity.
+     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
+     */
+    protected _defaultCallbackByKey: MapCallback<N>;
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to

package/lib/data-structures/binary-tree/binary-tree.js

@@ -102,24 +102,22 @@ export class BinaryTree {
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
+        this._loopType = IterationType.ITERATIVE;
         this._root = null;
         this._size = 0;
-        this._loopType = IterationType.ITERATIVE;
+        /**
+         * Time complexity is O(n)
+         * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
+         * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
+         * the tree's structure should be restored to its original state to maintain the tree's integrity.
+         * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
+         */
         this._defaultCallbackByKey = node => node.key;
         if (options !== undefined) {
             const { iterationType = IterationType.ITERATIVE } = options;
             this._loopType = iterationType;
         }
     }
-    /**
-     * Creates a new instance of BinaryTreeNode with the given key and value.
-     * @param {BinaryTreeNodeKey} key - The key for the new node.
-     * @param {N['val']} val - The value for the new node.
-     * @returns {N} - The newly created BinaryTreeNode.
-     */
-    createNode(key, val) {
-        return new BinaryTreeNode(key, val);
-    }
     /**
      * Get the root node of the binary tree.
      */
@@ -146,21 +144,13 @@ export class BinaryTree {
         this._loopType = v;
     }
     /**
-     * Swap the data of two nodes in the binary tree.
-     * @param {N} srcNode - The source node to swap.
-     * @param {N} destNode - The destination node to swap.
-     * @returns {N} - The destination node after the swap.
+     * Creates a new instance of BinaryTreeNode with the given key and value.
+     * @param {BinaryTreeNodeKey} key - The key for the new node.
+     * @param {N['val']} val - The value for the new node.
+     * @returns {N} - The newly created BinaryTreeNode.
      */
-    _swap(srcNode, destNode) {
-        const { key, val } = destNode;
-        const tempNode = this.createNode(key, val);
-        if (tempNode) {
-            destNode.key = srcNode.key;
-            destNode.val = srcNode.val;
-            srcNode.key = tempNode.key;
-            srcNode.val = tempNode.val;
-        }
-        return destNode;
+    createNode(key, val) {
+        return new BinaryTreeNode(key, val);
     }
     /**
      * Clear the binary tree, removing all nodes.
@@ -830,7 +820,6 @@ export class BinaryTree {
         }
         return ans;
     }
-    // --- start additional methods ---
     /**
      * The bfs function performs a breadth-first search traversal on a binary tree, executing a callback
      * function on each node.
@@ -895,13 +884,7 @@ export class BinaryTree {
             return node;
         }
     }
-    /**
-     * Time complexity is O(n)
-     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-     * the tree's structure should be restored to its original state to maintain the tree's integrity.
-     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
-     */
+    // --- start additional methods ---
     /**
      * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
      * algorithm and returns an array of values obtained by applying a callback function to each node.
@@ -1000,6 +983,23 @@ export class BinaryTree {
         }
         return ans;
     }
+    /**
+     * Swap the data of two nodes in the binary tree.
+     * @param {N} srcNode - The source node to swap.
+     * @param {N} destNode - The destination node to swap.
+     * @returns {N} - The destination node after the swap.
+     */
+    _swap(srcNode, destNode) {
+        const { key, val } = destNode;
+        const tempNode = this.createNode(key, val);
+        if (tempNode) {
+            destNode.key = srcNode.key;
+            destNode.val = srcNode.val;
+            srcNode.key = tempNode.key;
+            srcNode.val = tempNode.val;
+        }
+        return destNode;
+    }
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to

package/lib/data-structures/binary-tree/rb-tree.d.ts

@@ -2,8 +2,8 @@ import { BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions } from '../
 import { IBinaryTree } from '../../interfaces';
 import { BST, BSTNode } from './bst';
 export declare class RBTreeNode<V = any, FAMILY extends RBTreeNode<V, FAMILY> = RBTreeNodeNested<V>> extends BSTNode<V, FAMILY> {
-    private _color;
     constructor(key: BinaryTreeNodeKey, val?: V);
+    private _color;
     get color(): RBColor;
     set color(value: RBColor);
 }

package/lib/data-structures/binary-tree/tree-multiset.d.ts

@@ -10,6 +10,7 @@ import { BinaryTreeDeletedResult, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, FAMILY> {
+    count: number;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
@@ -21,7 +22,6 @@ export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
     constructor(key: BinaryTreeNodeKey, val?: V, count?: number);
-    count: number;
 }
 /**
  * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
@@ -46,14 +46,6 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
     createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
-    /**
-     * The function swaps the values of two nodes in a binary tree.
-     * @param {N} srcNode - The source node that needs to be swapped with the destination node.
-     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
-     * from `srcNode` will be swapped into.
-     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-     */
-    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The `add` function adds a new node to a binary search tree, updating the count if the key already
      * exists, and balancing the tree if necessary.
@@ -114,6 +106,14 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear(): void;
+    /**
+     * The function swaps the values of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that needs to be swapped with the destination node.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from `srcNode` will be swapped into.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     */
+    protected _swap(srcNode: N, destNode: N): N;
     /**
      * The function sets the value of the "_count" property.
      * @param {number} v - number

package/lib/data-structures/binary-tree/tree-multiset.js

@@ -45,29 +45,6 @@ export class TreeMultiset extends AVLTree {
     createNode(key, val, count) {
         return new TreeMultisetNode(key, val, count);
     }
-    /**
-     * The function swaps the values of two nodes in a binary tree.
-     * @param {N} srcNode - The source node that needs to be swapped with the destination node.
-     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
-     * from `srcNode` will be swapped into.
-     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-     */
-    _swap(srcNode, destNode) {
-        const { key, val, count, height } = destNode;
-        const tempNode = this.createNode(key, val, count);
-        if (tempNode) {
-            tempNode.height = height;
-            destNode.key = srcNode.key;
-            destNode.val = srcNode.val;
-            destNode.count = srcNode.count;
-            destNode.height = srcNode.height;
-            srcNode.key = tempNode.key;
-            srcNode.val = tempNode.val;
-            srcNode.count = tempNode.count;
-            srcNode.height = tempNode.height;
-        }
-        return destNode;
-    }
     /**
      * The `add` function adds a new node to a binary search tree, updating the count if the key already
      * exists, and balancing the tree if necessary.
@@ -336,6 +313,29 @@ export class TreeMultiset extends AVLTree {
         super.clear();
         this._setCount(0);
     }
+    /**
+     * The function swaps the values of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that needs to be swapped with the destination node.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from `srcNode` will be swapped into.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     */
+    _swap(srcNode, destNode) {
+        const { key, val, count, height } = destNode;
+        const tempNode = this.createNode(key, val, count);
+        if (tempNode) {
+            tempNode.height = height;
+            destNode.key = srcNode.key;
+            destNode.val = srcNode.val;
+            destNode.count = srcNode.count;
+            destNode.height = srcNode.height;
+            srcNode.key = tempNode.key;
+            srcNode.val = tempNode.val;
+            srcNode.count = tempNode.count;
+            srcNode.height = tempNode.height;
+        }
+        return destNode;
+    }
     /**
      * The function sets the value of the "_count" property.
      * @param {number} v - number

package/lib/data-structures/hash/hash-map.d.ts

@@ -7,24 +7,6 @@ import { HashFunction } from '../../types';
  * @license MIT License
  */
 export declare class HashMap<K, V> {
-    get hashFn(): HashFunction<K>;
-    set hashFn(value: HashFunction<K>);
-    get table(): Array<Array<[K, V]>>;
-    set table(value: Array<Array<[K, V]>>);
-    get capacityMultiplier(): number;
-    set capacityMultiplier(value: number);
-    get loadFactor(): number;
-    set loadFactor(value: number);
-    get initialCapacity(): number;
-    set initialCapacity(value: number);
-    get size(): number;
-    set size(value: number);
-    private _initialCapacity;
-    private _loadFactor;
-    private _capacityMultiplier;
-    private _size;
-    private _table;
-    private _hashFn;
     /**
      * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
      * multiplier, size, table array, and hash function.
@@ -38,6 +20,31 @@ export declare class HashMap<K, V> {
      * default hash function converts the key to a string, calculates the sum of the
      */
     constructor(initialCapacity?: number, loadFactor?: number, hashFn?: HashFunction<K>);
+    private _initialCapacity;
+    get initialCapacity(): number;
+    set initialCapacity(value: number);
+    private _loadFactor;
+    get loadFactor(): number;
+    set loadFactor(value: number);
+    private _capacityMultiplier;
+    get capacityMultiplier(): number;
+    set capacityMultiplier(value: number);
+    private _size;
+    get size(): number;
+    set size(value: number);
+    private _table;
+    get table(): Array<Array<[K, V]>>;
+    set table(value: Array<Array<[K, V]>>);
+    private _hashFn;
+    get hashFn(): HashFunction<K>;
+    set hashFn(value: HashFunction<K>);
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    delete(key: K): void;
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    clear(): void;
+    isEmpty(): boolean;
     private _hash;
     /**
      * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
@@ -46,11 +53,4 @@ export declare class HashMap<K, V> {
      * the number of buckets that the new table should have.
      */
     private resizeTable;
-    set(key: K, value: V): void;
-    get(key: K): V | undefined;
-    delete(key: K): void;
-    entries(): IterableIterator<[K, V]>;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    clear(): void;
-    isEmpty(): boolean;
 }

package/lib/data-structures/hash/hash-map.js

@@ -6,42 +6,6 @@
  * @license MIT License
  */
 export class HashMap {
-    get hashFn() {
-        return this._hashFn;
-    }
-    set hashFn(value) {
-        this._hashFn = value;
-    }
-    get table() {
-        return this._table;
-    }
-    set table(value) {
-        this._table = value;
-    }
-    get capacityMultiplier() {
-        return this._capacityMultiplier;
-    }
-    set capacityMultiplier(value) {
-        this._capacityMultiplier = value;
-    }
-    get loadFactor() {
-        return this._loadFactor;
-    }
-    set loadFactor(value) {
-        this._loadFactor = value;
-    }
-    get initialCapacity() {
-        return this._initialCapacity;
-    }
-    set initialCapacity(value) {
-        this._initialCapacity = value;
-    }
-    get size() {
-        return this._size;
-    }
-    set size(value) {
-        this._size = value;
-    }
     /**
      * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
      * multiplier, size, table array, and hash function.
@@ -71,30 +35,41 @@ export class HashMap {
                     return hash % this.table.length;
                 });
     }
-    _hash(key) {
-        return this._hashFn(key);
+    get initialCapacity() {
+        return this._initialCapacity;
     }
-    /**
-     * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
-     * rehashing the key-value pairs from the old table into the new table.
-     * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
-     * the number of buckets that the new table should have.
-     */
-    resizeTable(newCapacity) {
-        const newTable = new Array(newCapacity);
-        for (const bucket of this._table) {
-            // Note that this is this._table
-            if (bucket) {
-                for (const [key, value] of bucket) {
-                    const newIndex = this._hash(key) % newCapacity;
-                    if (!newTable[newIndex]) {
-                        newTable[newIndex] = [];
-                    }
-                    newTable[newIndex].push([key, value]);
-                }
-            }
-        }
-        this._table = newTable; // Again, here is this._table
+    set initialCapacity(value) {
+        this._initialCapacity = value;
+    }
+    get loadFactor() {
+        return this._loadFactor;
+    }
+    set loadFactor(value) {
+        this._loadFactor = value;
+    }
+    get capacityMultiplier() {
+        return this._capacityMultiplier;
+    }
+    set capacityMultiplier(value) {
+        this._capacityMultiplier = value;
+    }
+    get size() {
+        return this._size;
+    }
+    set size(value) {
+        this._size = value;
+    }
+    get table() {
+        return this._table;
+    }
+    set table(value) {
+        this._table = value;
+    }
+    get hashFn() {
+        return this._hashFn;
+    }
+    set hashFn(value) {
+        this._hashFn = value;
     }
     set(key, value) {
         const loadFactor = this.size / this.table.length;
@@ -164,4 +139,29 @@ export class HashMap {
     isEmpty() {
         return this.size === 0;
     }
+    _hash(key) {
+        return this._hashFn(key);
+    }
+    /**
+     * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
+     * rehashing the key-value pairs from the old table into the new table.
+     * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
+     * the number of buckets that the new table should have.
+     */
+    resizeTable(newCapacity) {
+        const newTable = new Array(newCapacity);
+        for (const bucket of this._table) {
+            // Note that this is this._table
+            if (bucket) {
+                for (const [key, value] of bucket) {
+                    const newIndex = this._hash(key) % newCapacity;
+                    if (!newTable[newIndex]) {
+                        newTable[newIndex] = [];
+                    }
+                    newTable[newIndex].push([key, value]);
+                }
+            }
+        }
+        this._table = newTable; // Again, here is this._table
+    }
 }

package/lib/data-structures/hash/hash-table.d.ts

@@ -13,19 +13,46 @@ export declare class HashTableNode<K, V> {
 }
 import { HashFunction } from '../../types';
 export declare class HashTable<K, V> {
-    get hashFn(): HashFunction<K>;
-    set hashFn(value: HashFunction<K>);
-    get buckets(): Array<HashTableNode<K, V> | null>;
-    set buckets(value: Array<HashTableNode<K, V> | null>);
-    get capacity(): number;
-    set capacity(value: number);
     private static readonly DEFAULT_CAPACITY;
     private static readonly LOAD_FACTOR;
+    constructor(capacity?: number, hashFn?: HashFunction<K>);
     private _capacity;
+    get capacity(): number;
+    set capacity(value: number);
     private _size;
+    get size(): number;
     private _buckets;
+    get buckets(): Array<HashTableNode<K, V> | null>;
+    set buckets(value: Array<HashTableNode<K, V> | null>);
     private _hashFn;
-    constructor(capacity?: number, hashFn?: HashFunction<K>);
+    get hashFn(): HashFunction<K>;
+    set hashFn(value: HashFunction<K>);
+    /**
+     * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
+     * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
+     * table. It is of type K, which is a generic type representing the key's data type.
+     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
+     * table.
+     * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
+     * value.
+     */
+    set(key: K, val: V): void;
+    /**
+     * The `get` function retrieves the value associated with a given key from a hash table.
+     * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data
+     * structure.
+     * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
+     * not found, it returns `undefined`.
+     */
+    get(key: K): V | undefined;
+    /**
+     * The delete function removes a key-value pair from a hash table.
+     * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
+     * table.
+     * @returns Nothing is being returned. The `delete` method has a return type of `void`, which means it does not return
+     * any value.
+     */
+    delete(key: K): void;
     /**
      * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
      * capacity of the data structure.
@@ -71,36 +98,9 @@ export declare class HashTable<K, V> {
      * @returns a number, which is the hash value of the key.
      */
     protected _objectHash(key: K): number;
-    /**
-     * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
-     * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
-     * table. It is of type K, which is a generic type representing the key's data type.
-     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
-     * table.
-     * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
-     * value.
-     */
-    set(key: K, val: V): void;
-    /**
-     * The `get` function retrieves the value associated with a given key from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data
-     * structure.
-     * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
-     * not found, it returns `undefined`.
-     */
-    get(key: K): V | undefined;
-    /**
-     * The delete function removes a key-value pair from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
-     * table.
-     * @returns Nothing is being returned. The `delete` method has a return type of `void`, which means it does not return
-     * any value.
-     */
-    delete(key: K): void;
     /**
      * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
      * capacity and rehashing all the existing key-value pairs into the new buckets.
      */
     protected _expand(): void;
-    get size(): number;
 }