min-heap-typed 1.39.4 → 1.39.6

package/dist/data-structures/graph/directed-graph.js

@@ -15,11 +15,11 @@ class DirectedVertex extends abstract_graph_1.AbstractVertex {
      * The constructor function initializes a vertex with an optional value.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex within a graph or data structure.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    constructor(key, val) {
-        super(key, val);
+    constructor(key, value) {
+        super(key, value);
     }
 }
 exports.DirectedVertex = DirectedVertex;
@@ -32,11 +32,11 @@ class DirectedEdge extends abstract_graph_1.AbstractEdge {
      * @param {VertexKey} dest - The `dest` parameter represents the destination vertex of an edge. It is of type
      * `VertexKey`, which is likely a unique identifier for a vertex in a graph.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value associated with
+     * @param {E} [value] - The `value` parameter is an optional parameter of type `E`. It represents the value associated with
      * the edge.
      */
-    constructor(src, dest, weight, val) {
-        super(weight, val);
+    constructor(src, dest, weight, value) {
+        super(weight, value);
         this._src = src;
         this._dest = dest;
     }
@@ -77,13 +77,13 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
      * The function creates a new vertex with an optional value and returns it.
      * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is of type `VertexKey`, which
      * could be a number or a string depending on how you want to identify your vertices.
-     * @param [val] - The 'val' parameter is an optional value that can be assigned to the vertex. If a value is provided,
-     * it will be assigned to the 'val' property of the vertex. If no value is provided, the 'val' property will be
+     * @param [value] - The 'value' parameter is an optional value that can be assigned to the vertex. If a value is provided,
+     * it will be assigned to the 'value' property of the vertex. If no value is provided, the 'value' property will be
      * assigned the same value as the 'key' parameter
-     * @returns a new instance of a DirectedVertex object, casted as type V.
+     * @returns a new instance of a DirectedVertex object, casted as type VO.
      */
-    createVertex(key, val) {
-        return new DirectedVertex(key, val !== null && val !== void 0 ? val : key);
+    createVertex(key, value) {
+        return new DirectedVertex(key, value !== null && value !== void 0 ? value : key);
     }
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
@@ -95,18 +95,18 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
      * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for the edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge. If no
      * weight is provided, it defaults to 1.
-     * @param [val] - The 'val' parameter is an optional value that can be assigned to the edge. It can be of any type and
+     * @param [value] - The 'value' parameter is an optional value that can be assigned to the edge. It can be of any type and
      * is used to store additional information or data associated with the edge.
-     * @returns a new instance of a DirectedEdge object, casted as type E.
+     * @returns a new instance of a DirectedEdge object, casted as type EO.
      */
-    createEdge(src, dest, weight, val) {
-        return new DirectedEdge(src, dest, weight !== null && weight !== void 0 ? weight : 1, val);
+    createEdge(src, dest, weight, value) {
+        return new DirectedEdge(src, dest, weight !== null && weight !== void 0 ? weight : 1, value);
     }
     /**
      * The `getEdge` function retrieves an edge between two vertices based on their source and destination IDs.
-     * @param {V | null | VertexKey} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
-     * @param {V | null | VertexKey} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
-     * destination vertex of the edge. It can be either a vertex object (`V`), a vertex ID (`VertexKey`), or `null` if the
+     * @param {VO | VertexKey | null} srcOrKey - The source vertex or its ID. It can be either a vertex object or a vertex ID.
+     * @param {VO | VertexKey | null} destOrKey - The `destOrKey` parameter in the `getEdge` function represents the
+     * destination vertex of the edge. It can be either a vertex object (`VO`), a vertex ID (`VertexKey`), or `null` if the
      * destination is not specified.
      * @returns the first edge found between the source and destination vertices, or null if no such edge is found.
      */
@@ -126,9 +126,9 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function removes an edge between two vertices in a graph and returns the removed edge.
-     * @param {V | VertexKey} srcOrKey - The source vertex or its ID.
-     * @param {V | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
-     * @returns the removed edge (E) if it exists, or null if either the source or destination vertex does not exist.
+     * @param {VO | VertexKey} srcOrKey - The source vertex or its ID.
+     * @param {VO | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
+     * @returns the removed edge (EO) if it exists, or null if either the source or destination vertex does not exist.
      */
     deleteEdgeSrcToDest(srcOrKey, destOrKey) {
         const src = this._getVertex(srcOrKey);
@@ -149,9 +149,9 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function removes an edge from a graph and returns the removed edge, or null if the edge was not found.
-     * @param {E} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
+     * @param {EO} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
      * and `dest`, which represent the source and destination vertices of the edge, respectively.
-     * @returns The method `deleteEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+     * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `null` if the edge does not exist.
      */
     deleteEdge(edge) {
         let removed = null;
@@ -171,11 +171,11 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function removes edges between two vertices and returns the removed edges.
-     * @param {VertexKey | V} v1 - The parameter `v1` can be either a `VertexKey` or a `V`. A `VertexKey` represents the
-     * unique identifier of a vertex in a graph, while `V` represents the actual vertex object.
-     * @param {VertexKey | V} v2 - The parameter `v2` represents either a `VertexKey` or a `V` object. It is used to specify
+     * @param {VertexKey | VO} v1 - The parameter `v1` can be either a `VertexKey` or a `VO`. A `VertexKey` represents the
+     * unique identifier of a vertex in a graph, while `VO` represents the actual vertex object.
+     * @param {VertexKey | VO} v2 - The parameter `v2` represents either a `VertexKey` or a `VO` object. It is used to specify
      * the second vertex in the edge that needs to be removed.
-     * @returns an array of removed edges (E[]).
+     * @returns an array of removed edges (EO[]).
      */
     deleteEdgesBetween(v1, v2) {
         const removed = [];
@@ -189,9 +189,9 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function `incomingEdgesOf` returns an array of incoming edges for a given vertex or vertex ID.
-     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
-     * @returns The method `incomingEdgesOf` returns an array of edges (`E[]`).
+     * @returns The method `incomingEdgesOf` returns an array of edges (`EO[]`).
      */
     incomingEdgesOf(vertexOrKey) {
         const target = this._getVertex(vertexOrKey);
@@ -202,9 +202,9 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function `outgoingEdgesOf` returns an array of outgoing edges from a given vertex or vertex ID.
-     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can accept either a vertex object (`V`) or a vertex ID
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can accept either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
-     * @returns The method `outgoingEdgesOf` returns an array of edges (`E[]`).
+     * @returns The method `outgoingEdgesOf` returns an array of edges (`EO[]`).
      */
     outgoingEdgesOf(vertexOrKey) {
         const target = this._getVertex(vertexOrKey);
@@ -215,7 +215,7 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function "degreeOf" returns the total degree of a vertex, which is the sum of its out-degree and in-degree.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
      * @returns The sum of the out-degree and in-degree of the specified vertex or vertex ID.
      */
     degreeOf(vertexOrKey) {
@@ -223,7 +223,7 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function "inDegreeOf" returns the number of incoming edges for a given vertex.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
      * @returns The number of incoming edges of the specified vertex or vertex ID.
      */
     inDegreeOf(vertexOrKey) {
@@ -231,7 +231,7 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function `outDegreeOf` returns the number of outgoing edges from a given vertex.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
      * @returns The number of outgoing edges from the specified vertex or vertex ID.
      */
     outDegreeOf(vertexOrKey) {
@@ -239,7 +239,7 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function "edgesOf" returns an array of both outgoing and incoming edges of a given vertex or vertex ID.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
      * @returns The function `edgesOf` returns an array of edges.
      */
     edgesOf(vertexOrKey) {
@@ -247,25 +247,25 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function "getEdgeSrc" returns the source vertex of an edge, or null if the edge does not exist.
-     * @param {E} e - The parameter "e" is of type E, which represents an edge in a graph.
-     * @returns either a vertex object (V) or null.
+     * @param {EO} e - The parameter "e" is of type EO, which represents an edge in a graph.
+     * @returns either a vertex object (VO) or null.
      */
     getEdgeSrc(e) {
         return this._getVertex(e.src);
     }
     /**
      * The function "getEdgeDest" returns the destination vertex of an edge.
-     * @param {E} e - The parameter "e" is of type "E", which represents an edge in a graph.
-     * @returns either a vertex object of type V or null.
+     * @param {EO} e - The parameter "e" is of type "EO", which represents an edge in a graph.
+     * @returns either a vertex object of type VO or null.
      */
     getEdgeDest(e) {
         return this._getVertex(e.dest);
     }
     /**
      * The function `getDestinations` returns an array of destination vertices connected to a given vertex.
-     * @param {V | VertexKey | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
-     * find the destinations. It can be either a `V` object, a `VertexKey` value, or `null`.
-     * @returns an array of vertices (V[]).
+     * @param {VO | VertexKey | null} vertex - The `vertex` parameter represents the starting vertex from which we want to
+     * find the destinations. It can be either a `VO` object, a `VertexKey` value, or `null`.
+     * @returns an array of vertices (VO[]).
      */
     getDestinations(vertex) {
         if (vertex === null) {
@@ -327,7 +327,7 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The `edgeSet` function returns an array of all the edges in the graph.
-     * @returns The `edgeSet()` method returns an array of edges (`E[]`).
+     * @returns The `edgeSet()` method returns an array of edges (`EO[]`).
      */
     edgeSet() {
         let edges = [];
@@ -338,9 +338,9 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function `getNeighbors` returns an array of neighboring vertices of a given vertex or vertex ID in a graph.
-     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
-     * @returns an array of vertices (V[]).
+     * @returns an array of vertices (VO[]).
      */
     getNeighbors(vertexOrKey) {
         const neighbors = [];
@@ -360,8 +360,8 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     /**
      * The function "getEndsOfEdge" returns the source and destination vertices of an edge if it exists in the graph,
      * otherwise it returns null.
-     * @param {E} edge - The parameter `edge` is of type `E`, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[V, V]` if the edge exists in the
+     * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph.
+     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
      * graph. If the edge does not exist, it returns `null`.
      */
     getEndsOfEdge(edge) {
@@ -379,7 +379,7 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function `_addEdgeOnly` adds an edge to a graph if the source and destination vertices exist.
-     * @param {E} edge - The parameter `edge` is of type `E`, which represents an edge in a graph. It is the edge that
+     * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph. It is the edge that
      * needs to be added to the graph.
      * @returns a boolean value. It returns true if the edge was successfully added to the graph, and false if either the
      * source or destination vertex does not exist in the graph.

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

@@ -10,10 +10,10 @@ export declare class MapVertex<V = any> extends DirectedVertex<V> {
      * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
      * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
      * values ranging from -180 to 180.
-     * @param {V} [val] - The "val" parameter is an optional value of type V. It is not required to be provided when
+     * @param {V} [value] - The "value" parameter is an optional value of type V. It is not required to be provided when
      * creating an instance of the class.
      */
-    constructor(key: VertexKey, lat: number, long: number, val?: V);
+    constructor(key: VertexKey, value: V, lat: number, long: number);
     private _lat;
     get lat(): number;
     set lat(value: number);
@@ -21,7 +21,7 @@ export declare class MapVertex<V = any> extends DirectedVertex<V> {
     get long(): number;
     set long(value: number);
 }
-export declare class MapEdge<V = any> extends DirectedEdge<V> {
+export declare class MapEdge<E = any> extends DirectedEdge<E> {
     /**
      * The constructor function initializes a new instance of a class with the given source, destination, weight, and
      * value.
@@ -29,12 +29,12 @@ export declare class MapEdge<V = any> extends DirectedEdge<V> {
      * a graph.
      * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store additional
+     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store additional
      * information or data associated with the edge.
      */
-    constructor(src: VertexKey, dest: VertexKey, weight?: number, val?: V);
+    constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E);
 }
-export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEdge = MapEdge> extends DirectedGraph<V, E> {
+export declare class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVertex<V>, EO extends MapEdge<E> = MapEdge<E>> extends DirectedGraph<V, E, VO, EO> {
     /**
      * The constructor function initializes the origin and bottomRight properties of a MapGraphCoordinate object.
      * @param {MapGraphCoordinate} origin - The `origin` parameter is a `MapGraphCoordinate` object that represents the
@@ -55,14 +55,14 @@ export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E exten
      * The function creates a new vertex with the given key, value, latitude, and longitude.
      * @param {VertexKey} key - The key parameter is the unique identifier for the vertex. It is of type VertexKey, which could
      * be a string or a number depending on how you define it in your code.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the vertex. It
-     * is of type `V['val']`, which means it should be of the same type as the `val` property of the vertex class `V`.
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the `value` property of the vertex. It
+     * is of type `V`, which means it should be of the same type as the `value` property of the vertex class `VO`.
      * @param {number} lat - The `lat` parameter represents the latitude of the vertex. It is a number that specifies the
      * position of the vertex on the Earth's surface in the north-south direction.
      * @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`.
+     * @returns The method is returning a new instance of the `MapVertex` class, casted as type `VO`.
      */
-    createVertex(key: VertexKey, lat?: number, long?: number, val?: V['val']): V;
+    createVertex(key: VertexKey, value?: V, lat?: number, long?: number): VO;
     /**
      * 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.
@@ -71,9 +71,9 @@ export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E exten
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. It
      * is used to assign a numerical value to the edge, which can be used in algorithms such as shortest path algorithms.
      * If the weight is not provided, it can be set to a default value or left undefined.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type,
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type,
      * depending on the specific implementation of the `MapEdge` class.
-     * @returns a new instance of the `MapEdge` class, cast as type `E`.
+     * @returns a new instance of the `MapEdge` class, cast as type `EO`.
      */
-    createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E['val']): E;
+    createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO;
 }

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

@@ -12,11 +12,11 @@ class MapVertex extends directed_graph_1.DirectedVertex {
      * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
      * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
      * values ranging from -180 to 180.
-     * @param {V} [val] - The "val" parameter is an optional value of type V. It is not required to be provided when
+     * @param {V} [value] - The "value" parameter is an optional value of type V. It is not required to be provided when
      * creating an instance of the class.
      */
-    constructor(key, lat, long, val) {
-        super(key, val);
+    constructor(key, value, lat, long) {
+        super(key, value);
         this._lat = lat;
         this._long = long;
     }
@@ -42,11 +42,11 @@ class MapEdge extends directed_graph_1.DirectedEdge {
      * a graph.
      * @param {VertexKey} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store additional
+     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store additional
      * information or data associated with the edge.
      */
-    constructor(src, dest, weight, val) {
-        super(src, dest, weight, val);
+    constructor(src, dest, weight, value) {
+        super(src, dest, weight, value);
     }
 }
 exports.MapEdge = MapEdge;
@@ -82,15 +82,15 @@ class MapGraph extends directed_graph_1.DirectedGraph {
      * The function creates a new vertex with the given key, value, latitude, and longitude.
      * @param {VertexKey} key - The key parameter is the unique identifier for the vertex. It is of type VertexKey, which could
      * be a string or a number depending on how you define it in your code.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the vertex. It
-     * is of type `V['val']`, which means it should be of the same type as the `val` property of the vertex class `V`.
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the `value` property of the vertex. It
+     * is of type `V`, which means it should be of the same type as the `value` property of the vertex class `VO`.
      * @param {number} lat - The `lat` parameter represents the latitude of the vertex. It is a number that specifies the
      * position of the vertex on the Earth's surface in the north-south direction.
      * @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`.
+     * @returns The method is returning a new instance of the `MapVertex` class, casted as type `VO`.
      */
-    createVertex(key, lat = this.origin[0], long = this.origin[1], val) {
-        return new MapVertex(key, lat, long, val);
+    createVertex(key, value, lat = this.origin[0], long = this.origin[1]) {
+        return new MapVertex(key, value, lat, long);
     }
     /**
      * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
@@ -100,12 +100,12 @@ class MapGraph extends directed_graph_1.DirectedGraph {
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. It
      * is used to assign a numerical value to the edge, which can be used in algorithms such as shortest path algorithms.
      * If the weight is not provided, it can be set to a default value or left undefined.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type,
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type,
      * depending on the specific implementation of the `MapEdge` class.
-     * @returns a new instance of the `MapEdge` class, cast as type `E`.
+     * @returns a new instance of the `MapEdge` class, cast as type `EO`.
      */
-    createEdge(src, dest, weight, val) {
-        return new MapEdge(src, dest, weight, val);
+    createEdge(src, dest, weight, value) {
+        return new MapEdge(src, dest, weight, value);
     }
 }
 exports.MapGraph = MapGraph;

package/dist/data-structures/graph/undirected-graph.d.ts

@@ -6,12 +6,12 @@ export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
      * The constructor function initializes a vertex with an optional value.
      * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
      * used to uniquely identify the vertex within a graph or network.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to initialize the value of the
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
-    constructor(key: VertexKey, val?: V);
+    constructor(key: VertexKey, value?: V);
 }
-export declare class UndirectedEdge<V = number> extends AbstractEdge<V> {
+export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -19,109 +19,109 @@ export declare class UndirectedEdge<V = number> extends AbstractEdge<V> {
      * @param {VertexKey} v2 - The parameter `v2` is a `VertexKey`, which represents the identifier of the second vertex in a
      * graph edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store a value associated
+     * @param {E} [value] - The "value" parameter is an optional parameter of type E. It is used to store a value associated
      * with the edge.
      */
-    constructor(v1: VertexKey, v2: VertexKey, weight?: number, val?: V);
+    constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E);
     private _vertices;
     get vertices(): [VertexKey, VertexKey];
     set vertices(v: [VertexKey, VertexKey]);
 }
-export declare class UndirectedGraph<V extends UndirectedVertex<any> = UndirectedVertex, E extends UndirectedEdge<any> = UndirectedEdge> extends AbstractGraph<V, E> implements IGraph<V, E> {
+export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVertex<V> = UndirectedVertex<V>, EO extends UndirectedEdge<E> = UndirectedEdge<E>> extends AbstractGraph<V, E, VO, EO> implements IGraph<V, E, VO, EO> {
     /**
      * The constructor initializes a new Map object to store edges.
      */
     constructor();
-    protected _edges: Map<V, E[]>;
-    get edges(): Map<V, E[]>;
+    protected _edges: Map<VO, EO[]>;
+    get edges(): Map<VO, EO[]>;
     /**
      * The function creates a new vertex with an optional value and returns it.
      * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is used to distinguish one
      * vertex from another in the graph.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the vertex. If a value is provided,
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the vertex. If a value is provided,
      * it will be used as the value of the vertex. If no value is provided, the `key` parameter will be used as the value of
      * the vertex.
-     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `V`.
+     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `VO`.
      */
-    createVertex(key: VertexKey, val?: V['val']): V;
+    createVertex(key: VertexKey, value?: VO['value']): VO;
     /**
      * The function creates an undirected edge between two vertices with an optional weight and value.
      * @param {VertexKey} v1 - The parameter `v1` represents the first vertex of the edge.
      * @param {VertexKey} v2 - The parameter `v2` represents the second vertex of the edge.
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
      * no weight is provided, it defaults to 1.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type and
+     * @param [value] - The `value` parameter is an optional value that can be assigned to the edge. It can be of any type and
      * is used to store additional information or data associated with the edge.
-     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `E`.
+     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `EO`.
      */
-    createEdge(v1: VertexKey, v2: VertexKey, weight?: number, val?: E['val']): E;
+    createEdge(v1: VertexKey, v2: VertexKey, weight?: number, value?: EO['value']): EO;
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-     * @param {V | null | VertexKey} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * @param {VO | VertexKey | null} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
-     * @param {V | null | VertexKey} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * @param {VO | VertexKey | null} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `null`, or `VertexKey` (vertex ID).
-     * @returns an edge (E) or null.
+     * @returns an edge (EO) or null.
      */
-    getEdge(v1: V | null | VertexKey, v2: V | null | VertexKey): E | null;
+    getEdge(v1: VO | VertexKey | null, v2: VO | VertexKey | null): EO | null;
     /**
      * The function removes an edge between two vertices in a graph and returns the removed edge.
-     * @param {V | VertexKey} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexKey`).
-     * @param {V | VertexKey} v2 - V | VertexKey - This parameter can be either a vertex object (V) or a vertex ID
+     * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+     * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
      * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-     * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
+     * @returns the removed edge (EO) if it exists, or null if either of the vertices (VO) does not exist.
      */
-    deleteEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null;
+    deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | null;
     /**
      * The deleteEdge function removes an edge between two vertices in a graph.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The method is returning either the removed edge (of type EO) or null if the edge was not found.
      */
-    deleteEdge(edge: E): E | null;
+    deleteEdge(edge: EO): EO | null;
     /**
      * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
      * vertex.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
      * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
      * edges connected to that vertex.
      */
-    degreeOf(vertexOrKey: VertexKey | V): number;
+    degreeOf(vertexOrKey: VertexKey | VO): number;
     /**
      * The function returns the edges of a given vertex or vertex ID.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`. A `VertexKey` is a
-     * unique identifier for a vertex in a graph, while `V` represents the type of the vertex.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`. A `VertexKey` is a
+     * unique identifier for a vertex in a graph, while `VO` represents the type of the vertex.
      * @returns an array of edges.
      */
-    edgesOf(vertexOrKey: VertexKey | V): E[];
+    edgesOf(vertexOrKey: VertexKey | VO): EO[];
     /**
      * The function "edgeSet" returns an array of unique edges from a set of edges.
-     * @returns The method `edgeSet()` returns an array of type `E[]`.
+     * @returns The method `edgeSet()` returns an array of type `EO[]`.
      */
-    edgeSet(): E[];
+    edgeSet(): EO[];
     /**
      * The function "getNeighbors" returns an array of neighboring vertices for a given vertex or vertex ID.
-     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
-     * @returns an array of vertices (V[]).
+     * @returns an array of vertices (VO[]).
      */
-    getNeighbors(vertexOrKey: V | VertexKey): V[];
+    getNeighbors(vertexOrKey: VO | VertexKey): VO[];
     /**
      * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
      * it returns null.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[V, V]` if the edge exists in the
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
      * graph. If the edge does not exist, it returns `null`.
      */
-    getEndsOfEdge(edge: E): [V, V] | null;
+    getEndsOfEdge(edge: EO): [VO, VO] | null;
     /**
      * The function adds an edge to the graph by updating the adjacency list with the vertices of the edge.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
      * @returns a boolean value.
      */
-    protected _addEdgeOnly(edge: E): boolean;
+    protected _addEdgeOnly(edge: EO): boolean;
     /**
      * The function sets the edges of a graph.
-     * @param v - A map where the keys are of type V and the values are arrays of type E.
+     * @param v - A map where the keys are of type VO and the values are arrays of type EO.
      */
-    protected _setEdges(v: Map<V, E[]>): void;
+    protected _setEdges(v: Map<VO, EO[]>): void;
 }