data-structure-typed 1.39.0 → 1.39.2

package/dist/mjs/data-structures/binary-tree/bst.js

@@ -209,7 +209,7 @@ class BST extends binary_tree_1.BinaryTree {
      * callback.
      * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter is used to specify the
      * property of the binary tree node that you want to search for. It can be either a specific key
-     * value (`BinaryTreeNodeKey`) or a custom callback function (`MapCallback<N>`) that determines
+     * value (`BinaryTreeNodeKey`) or a custom callback function (`OneParamCallback<N>`) that determines
      * whether a node matches the desired property.
      * @param callback - The `callback` parameter is a function that is used to determine whether a node
      * matches the desired property. It takes a node as input and returns a boolean value indicating
@@ -340,7 +340,7 @@ class BST extends binary_tree_1.BinaryTree {
      * (`BinaryTreeNodeKey`), or `null` to
      * @param iterationType - The `iterationType` parameter determines whether the traversal should be
      * done recursively or iteratively. It can have two possible values:
-     * @returns The function `lesserOrGreaterTraverse` returns an array of `MapCallbackReturn<N>`.
+     * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<OneParamCallback<N>>`.
      */
     lesserOrGreaterTraverse(callback = this._defaultCallbackByKey, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
         if (typeof targetNode === 'number')

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
-import { BinaryTreeDeletedResult, IterationType, MapCallback } from '../../types';
+import { BinaryTreeDeletedResult, IterationType, OneParamCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, N> {
@@ -105,7 +105,7 @@ export declare class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = Tr
      * decremented by 1 and
      * @returns The method `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    delete<C extends MapCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    delete<C extends OneParamCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     /**
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */

package/dist/mjs/data-structures/graph/abstract-graph.d.ts

@@ -103,7 +103,7 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any> = Abst
      * @returns a boolean value. It returns true if at least one vertex was successfully removed, and false if no vertices
      * were removed.
      */
-    removeAllVertices(vertices: V[] | VertexKey[]): boolean;
+    removeManyVertices(vertices: V[] | VertexKey[]): boolean;
     /**
      * The function checks if there is an edge between two vertices and returns a boolean value indicating the result.
      * @param {VertexKey | V} v1 - The parameter v1 can be either a VertexKey or a V. A VertexKey represents the unique

package/dist/mjs/data-structures/graph/abstract-graph.js

@@ -136,7 +136,7 @@ class AbstractGraph {
      * @returns a boolean value. It returns true if at least one vertex was successfully removed, and false if no vertices
      * were removed.
      */
-    removeAllVertices(vertices) {
+    removeManyVertices(vertices) {
         const removed = [];
         for (const v of vertices) {
             removed.push(this.deleteVertex(v));

package/dist/mjs/data-structures/graph/map-graph.d.ts

@@ -62,7 +62,7 @@ export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E exten
      * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
      * @returns The method is returning a new instance of the `MapVertex` class, casted as type `V`.
      */
-    createVertex(key: VertexKey, val?: V['val'], lat?: number, long?: number): V;
+    createVertex(key: VertexKey, lat?: number, long?: number, val?: V['val']): V;
     /**
      * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
      * @param {VertexKey} src - The source vertex ID of the edge. It represents the starting point of the edge.

package/dist/mjs/data-structures/graph/map-graph.js

@@ -92,7 +92,7 @@ class MapGraph extends directed_graph_1.DirectedGraph {
      * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
      * @returns The method is returning a new instance of the `MapVertex` class, casted as type `V`.
      */
-    createVertex(key, val, lat = this.origin[0], long = this.origin[1]) {
+    createVertex(key, lat = this.origin[0], long = this.origin[1], val) {
         return new MapVertex(key, lat, long, val);
     }
     /**

package/dist/mjs/data-structures/linked-list/doubly-linked-list.d.ts

@@ -60,11 +60,11 @@ export declare class DoublyLinkedList<E = any> {
      */
     pop(): E | undefined;
     /**
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
+     * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
      * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
      * list is empty, it returns null.
      */
-    pollLast(): E | undefined;
+    popLast(): E | undefined;
     /**
      * The `shift()` function removes and returns the value of the first node in a doubly linked list.
      * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
@@ -72,11 +72,11 @@ export declare class DoublyLinkedList<E = any> {
      */
     shift(): E | undefined;
     /**
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
+     * The `popFirst()` function removes and returns the value of the first node in a doubly linked list.
      * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
      * list.
      */
-    pollFirst(): E | undefined;
+    popFirst(): E | undefined;
     /**
      * The unshift function adds a new node with the given value to the beginning of a doubly linked list.
      * @param {E} val - The `val` parameter represents the value of the new node that will be added to the beginning of the
@@ -90,15 +90,15 @@ export declare class DoublyLinkedList<E = any> {
      */
     addFirst(val: E): void;
     /**
-     * The `peekFirst` function returns the first node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
+     * The `getFirst` function returns the first node in a doubly linked list, or null if the list is empty.
+     * @returns The method `getFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
      */
-    peekFirst(): E | undefined;
+    getFirst(): E | undefined;
     /**
-     * The `peekLast` function returns the last node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
+     * The `getLast` function returns the last node in a doubly linked list, or null if the list is empty.
+     * @returns The method `getLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
      */
-    peekLast(): E | undefined;
+    getLast(): E | undefined;
     /**
      * The `getAt` function returns the value at a specified index in a linked list, or null if the index is out of bounds.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
@@ -123,7 +123,7 @@ export declare class DoublyLinkedList<E = any> {
      * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `val`
      * is found in the linked list. If no such node is found, it returns `null`.
      */
-    findNode(val: E | null): DoublyLinkedListNode<E> | null;
+    getNode(val: E | null): DoublyLinkedListNode<E> | null;
     /**
      * The `insert` function inserts a value at a specified index in a doubly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
@@ -134,6 +134,17 @@ export declare class DoublyLinkedList<E = any> {
      * if the index is out of bounds.
      */
     insertAt(index: number, val: E): boolean;
+    /**
+     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * itself.
+     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
+     * list.
+     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
+     * insertion fails.
+     */
+    insertBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
     /**
      * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
      * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
@@ -142,8 +153,14 @@ export declare class DoublyLinkedList<E = any> {
      * bounds.
      */
     deleteAt(index: number): E | undefined;
-    delete(valOrNode: E): boolean;
-    delete(valOrNode: DoublyLinkedListNode<E>): boolean;
+    /**
+     * The `delete` function removes a node from a doubly linked list based on either the node itself or its value.
+     * @param {E | DoublyLinkedListNode<E>} valOrNode - The `valOrNode` parameter can accept either a value of type `E` or
+     * a `DoublyLinkedListNode<E>` object.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the value or node was successfully
+     * deleted from the doubly linked list, and `false` if the value or node was not found in the list.
+     */
+    delete(valOrNode: E | DoublyLinkedListNode<E> | null): boolean;
     /**
      * The `toArray` function converts a linked list into an array.
      * @returns The `toArray()` method is returning an array of type `E[]`.
@@ -175,19 +192,19 @@ export declare class DoublyLinkedList<E = any> {
      */
     indexOf(val: E): number;
     /**
-     * The `findLast` function iterates through a linked list from the last node to the first node and returns the last
+     * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
      * value that satisfies the given callback function, or null if no value satisfies the callback.
      * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
      * function is used to determine whether a given value satisfies a certain condition.
-     * @returns The method `findLast` returns the last value in the linked list that satisfies the condition specified by
+     * @returns The method `findBackward` returns the last value in the linked list that satisfies the condition specified by
      * the callback function. If no value satisfies the condition, it returns `null`.
      */
-    findLast(callback: (val: E) => boolean): E | null;
+    findBackward(callback: (val: E) => boolean): E | null;
     /**
-     * The `toArrayReverse` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toArrayReverse()` function returns an array of type `E[]`.
+     * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
+     * @returns The `toArrayBackward()` function returns an array of type `E[]`.
      */
-    toArrayReverse(): E[];
+    toArrayBackward(): E[];
     /**
      * The `reverse` function reverses the order of the elements in a doubly linked list.
      */
@@ -227,17 +244,18 @@ export declare class DoublyLinkedList<E = any> {
      * elements in the linked list.
      */
     reduce<U>(callback: (accumulator: U, val: E) => U, initialValue: U): U;
-    insertAfter(existingValueOrNode: E, newValue: E): boolean;
-    insertAfter(existingValueOrNode: DoublyLinkedListNode<E>, newValue: E): boolean;
     /**
-     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
      * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
-     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * after which the new value will be inserted. It can be either the value of the existing node or the existing node
      * itself.
-     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
-     * list.
-     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
-     * insertion fails.
+     * @param {E} newValue - The value that you want to insert into the doubly linked list.
+     * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
+     * existing value or node is not found in the doubly linked list.
      */
-    insertBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
+    insertAfter(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
+    [Symbol.iterator](): Generator<E, void, unknown>;
 }

package/dist/mjs/data-structures/linked-list/doubly-linked-list.js

@@ -130,11 +130,11 @@ class DoublyLinkedList {
         return removedNode.val;
     }
     /**
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
+     * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
      * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
      * list is empty, it returns null.
      */
-    pollLast() {
+    popLast() {
         return this.pop();
     }
     /**
@@ -158,11 +158,11 @@ class DoublyLinkedList {
         return removedNode.val;
     }
     /**
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
+     * The `popFirst()` function removes and returns the value of the first node in a doubly linked list.
      * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
      * list.
      */
-    pollFirst() {
+    popFirst() {
         return this.shift();
     }
     /**
@@ -192,17 +192,17 @@ class DoublyLinkedList {
         this.unshift(val);
     }
     /**
-     * The `peekFirst` function returns the first node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
+     * The `getFirst` function returns the first node in a doubly linked list, or null if the list is empty.
+     * @returns The method `getFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
      */
-    peekFirst() {
+    getFirst() {
         return this.head?.val;
     }
     /**
-     * The `peekLast` function returns the last node in a doubly linked list, or null if the list is empty.
-     * @returns The method `peekLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
+     * The `getLast` function returns the last node in a doubly linked list, or null if the list is empty.
+     * @returns The method `getLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
      */
-    peekLast() {
+    getLast() {
         return this.tail?.val;
     }
     /**
@@ -245,7 +245,7 @@ class DoublyLinkedList {
      * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `val`
      * is found in the linked list. If no such node is found, it returns `null`.
      */
-    findNode(val) {
+    getNode(val) {
         let current = this.head;
         while (current) {
             if (current.val === val) {
@@ -285,6 +285,40 @@ class DoublyLinkedList {
         this._length++;
         return true;
     }
+    /**
+     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * itself.
+     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
+     * list.
+     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
+     * insertion fails.
+     */
+    insertBefore(existingValueOrNode, newValue) {
+        let existingNode;
+        if (existingValueOrNode instanceof DoublyLinkedListNode) {
+            existingNode = existingValueOrNode;
+        }
+        else {
+            existingNode = this.getNode(existingValueOrNode);
+        }
+        if (existingNode) {
+            const newNode = new DoublyLinkedListNode(newValue);
+            newNode.prev = existingNode.prev;
+            if (existingNode.prev) {
+                existingNode.prev.next = newNode;
+            }
+            newNode.next = existingNode;
+            existingNode.prev = newNode;
+            if (existingNode === this.head) {
+                this.head = newNode;
+            }
+            this._length++;
+            return true;
+        }
+        return false;
+    }
     /**
      * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
      * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
@@ -320,7 +354,7 @@ class DoublyLinkedList {
             node = valOrNode;
         }
         else {
-            node = this.findNode(valOrNode);
+            node = this.getNode(valOrNode);
         }
         if (node) {
             if (node === this.head) {
@@ -405,14 +439,14 @@ class DoublyLinkedList {
         return -1;
     }
     /**
-     * The `findLast` function iterates through a linked list from the last node to the first node and returns the last
+     * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
      * value that satisfies the given callback function, or null if no value satisfies the callback.
      * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
      * function is used to determine whether a given value satisfies a certain condition.
-     * @returns The method `findLast` returns the last value in the linked list that satisfies the condition specified by
+     * @returns The method `findBackward` returns the last value in the linked list that satisfies the condition specified by
      * the callback function. If no value satisfies the condition, it returns `null`.
      */
-    findLast(callback) {
+    findBackward(callback) {
         let current = this.tail;
         while (current) {
             if (callback(current.val)) {
@@ -423,10 +457,10 @@ class DoublyLinkedList {
         return null;
     }
     /**
-     * The `toArrayReverse` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toArrayReverse()` function returns an array of type `E[]`.
+     * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
+     * @returns The `toArrayBackward()` function returns an array of type `E[]`.
      */
-    toArrayReverse() {
+    toArrayBackward() {
         const array = [];
         let current = this.tail;
         while (current) {
@@ -531,7 +565,7 @@ class DoublyLinkedList {
             existingNode = existingValueOrNode;
         }
         else {
-            existingNode = this.findNode(existingValueOrNode);
+            existingNode = this.getNode(existingValueOrNode);
         }
         if (existingNode) {
             const newNode = new DoublyLinkedListNode(newValue);
@@ -550,38 +584,14 @@ class DoublyLinkedList {
         return false;
     }
     /**
-     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
-     * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
-     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
-     * itself.
-     * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
-     * list.
-     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
-     * insertion fails.
+     * The function returns an iterator that iterates over the values of a linked list.
      */
-    insertBefore(existingValueOrNode, newValue) {
-        let existingNode;
-        if (existingValueOrNode instanceof DoublyLinkedListNode) {
-            existingNode = existingValueOrNode;
-        }
-        else {
-            existingNode = this.findNode(existingValueOrNode);
-        }
-        if (existingNode) {
-            const newNode = new DoublyLinkedListNode(newValue);
-            newNode.prev = existingNode.prev;
-            if (existingNode.prev) {
-                existingNode.prev.next = newNode;
-            }
-            newNode.next = existingNode;
-            existingNode.prev = newNode;
-            if (existingNode === this.head) {
-                this.head = newNode;
-            }
-            this._length++;
-            return true;
+    *[Symbol.iterator]() {
+        let current = this.head;
+        while (current) {
+            yield current.val;
+            current = current.next;
         }
-        return false;
     }
 }
 exports.DoublyLinkedList = DoublyLinkedList;

package/dist/mjs/data-structures/linked-list/singly-linked-list.d.ts

@@ -39,13 +39,18 @@ export declare class SinglyLinkedList<E = any> {
      * @returns The `fromArray` function returns a `SinglyLinkedList` object.
      */
     static fromArray<E>(data: E[]): SinglyLinkedList<E>;
-    getLength(): number;
     /**
-     * The `push` function adds a new node with the given data to the end of a singly linked list.
-     * @param {E} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of
      * any type (E) as specified in the generic type declaration of the class or function.
      */
-    push(data: E): void;
+    push(val: E): void;
+    /**
+     * The `push` function adds a new node with the given val to the end of a singly linked list.
+     * @param {E} val - The "val" parameter represents the value that you want to add to the linked list. It can be of
+     * any type (E) as specified in the generic type declaration of the class or function.
+     */
+    addLast(val: E): void;
     /**
      * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
@@ -53,17 +58,35 @@ export declare class SinglyLinkedList<E = any> {
      * the linked list is empty, it returns `null`.
      */
     pop(): E | undefined;
+    /**
+     * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
+     * pointers accordingly.
+     * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
+     * the linked list is empty, it returns `null`.
+     */
+    popLast(): E | undefined;
     /**
      * The `shift()` function removes and returns the value of the first node in a linked list.
      * @returns The value of the node that is being removed from the beginning of the linked list.
      */
     shift(): E | undefined;
+    /**
+     * The `popFirst()` function removes and returns the value of the first node in a linked list.
+     * @returns The value of the node that is being removed from the beginning of the linked list.
+     */
+    popFirst(): E | undefined;
     /**
      * The unshift function adds a new node with the given value to the beginning of a singly linked list.
      * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
      * linked list.
      */
     unshift(val: E): void;
+    /**
+     * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
+     * @param {E} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
+     * linked list.
+     */
+    addFirst(val: E): void;
     /**
      * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
@@ -148,7 +171,7 @@ export declare class SinglyLinkedList<E = any> {
      * @returns a `SinglyLinkedListNode<E>` if a node with the specified value is found in the linked list. If no node with
      * the specified value is found, the function returns `null`.
      */
-    findNode(value: E): SinglyLinkedListNode<E> | null;
+    getNode(value: E): SinglyLinkedListNode<E> | null;
     /**
      * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
@@ -158,13 +181,58 @@ export declare class SinglyLinkedList<E = any> {
      * inserted before the existing value, and `false` otherwise.
      */
     insertBefore(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
-    insertAfter(existingValueOrNode: E, newValue: E): boolean;
-    insertAfter(existingValueOrNode: SinglyLinkedListNode<E>, newValue: E): boolean;
+    /**
+     * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
+     * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
+     * the new value will be inserted. It can be either the value of the existing node or the existing node itself.
+     * @param {E} newValue - The value that you want to insert into the linked list after the existing value or node.
+     * @returns The method returns a boolean value. It returns true if the new value was successfully inserted after the
+     * existing value or node, and false if the existing value or node was not found in the linked list.
+     */
+    insertAfter(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
     /**
      * The function counts the number of occurrences of a given value in a linked list.
      * @param {E} value - The value parameter is the value that you want to count the occurrences of in the linked list.
      * @returns The count of occurrences of the given value in the linked list.
      */
     countOccurrences(value: E): number;
+    /**
+     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+     * @param callback - The callback parameter is a function that takes two arguments: val and index. The val argument
+     * represents the value of the current node in the linked list, and the index argument represents the index of the
+     * current node in the linked list.
+     */
+    forEach(callback: (val: E, index: number) => void): void;
+    /**
+     * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
+     * SinglyLinkedList with the transformed values.
+     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+     * the original SinglyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
+     * SinglyLinkedList).
+     * @returns The `map` function is returning a new instance of `SinglyLinkedList<U>` that contains the mapped values.
+     */
+    map<U>(callback: (val: E) => U): SinglyLinkedList<U>;
+    /**
+     * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
+     * elements that satisfy the given callback function.
+     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
+     * It is used to determine whether a value should be included in the filtered list or not.
+     * @returns The filtered list, which is an instance of the SinglyLinkedList class.
+     */
+    filter(callback: (val: E) => boolean): SinglyLinkedList<E>;
+    /**
+     * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
+     * single value.
+     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `val`. It is
+     * used to perform a specific operation on each element of the linked list.
+     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * point for the reduction operation.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
+     * elements in the linked list.
+     */
+    reduce<U>(callback: (accumulator: U, val: E) => U, initialValue: U): U;
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
     [Symbol.iterator](): Generator<E, void, unknown>;
 }