graph-typed 1.39.5 → 1.40.0

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

@@ -7,25 +7,13 @@
  */
 import type { SegmentTreeNodeVal } from '../../types';
 export declare class SegmentTreeNode {
-    constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null);
-    private _start;
-    get start(): number;
-    set start(v: number);
-    private _end;
-    get end(): number;
-    set end(v: number);
-    private _val;
-    get val(): SegmentTreeNodeVal | null;
-    set val(v: SegmentTreeNodeVal | null);
-    private _sum;
-    get sum(): number;
-    set sum(v: number);
-    private _left;
-    get left(): SegmentTreeNode | null;
-    set left(v: SegmentTreeNode | null);
-    private _right;
-    get right(): SegmentTreeNode | null;
-    set right(v: SegmentTreeNode | null);
+    start: number;
+    end: number;
+    value: SegmentTreeNodeVal | null;
+    sum: number;
+    left: SegmentTreeNode | null;
+    right: SegmentTreeNode | null;
+    constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null);
 }
 export declare class SegmentTree {
     /**
@@ -38,13 +26,13 @@ export declare class SegmentTree {
      * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
      */
     constructor(values: number[], start?: number, end?: number);
-    private _values;
+    protected _values: number[];
     get values(): number[];
-    private _start;
+    protected _start: number;
     get start(): number;
-    private _end;
+    protected _end: number;
     get end(): number;
-    private _root;
+    protected _root: SegmentTreeNode | null;
     get root(): SegmentTreeNode | null;
     /**
      * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
@@ -62,12 +50,12 @@ export declare class SegmentTree {
      * updated.
      * @param {number} sum - The `sum` parameter represents the new value that should be assigned to the `sum` property of
      * the `SegmentTreeNode` at the specified `index`.
-     * @param {SegmentTreeNodeVal} [val] - The `val` parameter is an optional value that can be assigned to the `val`
+     * @param {SegmentTreeNodeVal} [value] - The `value` parameter is an optional value that can be assigned to the `value`
      * property of the `SegmentTreeNode` object. It is not currently used in the code, but you can uncomment the line `//
-     * cur.val = val;` and pass a value for `val` in the
+     * cur.value = value;` and pass a value for `value` in the
      * @returns The function does not return anything.
      */
-    updateNode(index: number, sum: number, val?: SegmentTreeNodeVal): void;
+    updateNode(index: number, sum: number, value?: SegmentTreeNodeVal): void;
     /**
      * The function `querySumByRange` calculates the sum of values within a given range in a segment tree.
      * @param {number} indexA - The starting index of the range for which you want to calculate the sum.
@@ -76,8 +64,4 @@ export declare class SegmentTree {
      * @returns The function `querySumByRange` returns a number.
      */
     querySumByRange(indexA: number, indexB: number): number;
-    protected _setValues(value: number[]): void;
-    protected _setStart(value: number): void;
-    protected _setEnd(value: number): void;
-    protected _setRoot(v: SegmentTreeNode | null): void;
 }

package/dist/data-structures/binary-tree/segment-tree.js

@@ -9,53 +9,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentTree = exports.SegmentTreeNode = void 0;
 class SegmentTreeNode {
-    constructor(start, end, sum, val) {
-        this._start = 0;
-        this._end = 0;
-        this._val = null;
-        this._sum = 0;
-        this._left = null;
-        this._right = null;
-        this._start = start;
-        this._end = end;
-        this._sum = sum;
-        this._val = val || null;
-    }
-    get start() {
-        return this._start;
-    }
-    set start(v) {
-        this._start = v;
-    }
-    get end() {
-        return this._end;
-    }
-    set end(v) {
-        this._end = v;
-    }
-    get val() {
-        return this._val;
-    }
-    set val(v) {
-        this._val = v;
-    }
-    get sum() {
-        return this._sum;
-    }
-    set sum(v) {
-        this._sum = v;
-    }
-    get left() {
-        return this._left;
-    }
-    set left(v) {
-        this._left = v;
-    }
-    get right() {
-        return this._right;
-    }
-    set right(v) {
-        this._right = v;
+    constructor(start, end, sum, value) {
+        this.start = 0;
+        this.end = 0;
+        this.value = null;
+        this.sum = 0;
+        this.left = null;
+        this.right = null;
+        this.start = start;
+        this.end = end;
+        this.sum = sum;
+        this.value = value || null;
     }
 }
 exports.SegmentTreeNode = SegmentTreeNode;
@@ -126,39 +90,39 @@ class SegmentTree {
      * updated.
      * @param {number} sum - The `sum` parameter represents the new value that should be assigned to the `sum` property of
      * the `SegmentTreeNode` at the specified `index`.
-     * @param {SegmentTreeNodeVal} [val] - The `val` parameter is an optional value that can be assigned to the `val`
+     * @param {SegmentTreeNodeVal} [value] - The `value` parameter is an optional value that can be assigned to the `value`
      * property of the `SegmentTreeNode` object. It is not currently used in the code, but you can uncomment the line `//
-     * cur.val = val;` and pass a value for `val` in the
+     * cur.value = value;` and pass a value for `value` in the
      * @returns The function does not return anything.
      */
-    updateNode(index, sum, val) {
+    updateNode(index, sum, value) {
         const root = this.root || null;
         if (!root) {
             return;
         }
-        const dfs = (cur, index, sum, val) => {
+        const dfs = (cur, index, sum, value) => {
             if (cur.start === cur.end && cur.start === index) {
                 cur.sum = sum;
-                if (val !== undefined)
-                    cur.val = val;
+                if (value !== undefined)
+                    cur.value = value;
                 return;
             }
             const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
             if (index <= mid) {
                 if (cur.left) {
-                    dfs(cur.left, index, sum, val);
+                    dfs(cur.left, index, sum, value);
                 }
             }
             else {
                 if (cur.right) {
-                    dfs(cur.right, index, sum, val);
+                    dfs(cur.right, index, sum, value);
                 }
             }
             if (cur.left && cur.right) {
                 cur.sum = cur.left.sum + cur.right.sum;
             }
         };
-        dfs(root, index, sum, val);
+        dfs(root, index, sum, value);
     }
     /**
      * The function `querySumByRange` calculates the sum of values within a given range in a segment tree.
@@ -212,17 +176,5 @@ class SegmentTree {
         };
         return dfs(root, indexA, indexB);
     }
-    _setValues(value) {
-        this._values = value;
-    }
-    _setStart(value) {
-        this._start = value;
-    }
-    _setEnd(value) {
-        this._end = value;
-    }
-    _setRoot(v) {
-        this._root = v;
-    }
 }
 exports.SegmentTree = SegmentTree;

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BTNKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
-import { BinaryTreeDeletedResult, IterationType, BTNCallback } from '../../types';
+import { BinaryTreeDeletedResult, BTNCallback, IterationType } 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> {
@@ -15,13 +15,13 @@ export declare class TreeMultisetNode<V = any, N extends TreeMultisetNode<V, N>
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
      * of the binary tree node.
-     * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value of the binary
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
      * tree node. If no value is provided, it will be `undefined`.
      * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
      * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
-    constructor(key: BTNKey, val?: V, count?: number);
+    constructor(key: BTNKey, value?: V, 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.
@@ -40,26 +40,26 @@ export declare class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = Tr
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
-     * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
+     * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
-    createNode(key: BTNKey, val?: V, count?: number): N;
+    createNode(key: BTNKey, value?: V, count?: number): 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.
      * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
      * `BTNKey` (which represents the key of the node to be added), a `N` (which represents a
      * node to be added), or `null` (which represents a null node).
-     * @param [val] - The `val` parameter represents the value associated with the key that is being
+     * @param [value] - The `value` parameter represents the value associated with the key that is being
      * added to the binary tree.
      * @param [count=1] - The `count` parameter represents the number of occurrences of the key/value
      * pair that will be added to the binary tree. It has a default value of 1, which means that if no
      * count is specified, the default count will be 1.
      * @returns The function `add` returns a value of type `N | null | undefined`.
      */
-    add(keyOrNode: BTNKey | N | null, val?: V, count?: number): N | null | undefined;
+    add(keyOrNode: BTNKey | N | null, value?: V, count?: number): N | null | undefined;
     /**
      * The function adds a new node to a binary tree if there is an available slot in the parent node.
      * @param {N | null} newNode - The `newNode` parameter represents the node that needs to be added to

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

@@ -8,14 +8,14 @@ class TreeMultisetNode extends avl_tree_1.AVLTreeNode {
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
      * of the binary tree node.
-     * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value of the binary
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
      * tree node. If no value is provided, it will be `undefined`.
      * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
      * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
-    constructor(key, val, count = 1) {
-        super(key, val);
+    constructor(key, value, count = 1) {
+        super(key, value);
         this.count = count;
     }
 }
@@ -41,13 +41,13 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
-     * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
+     * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
-    createNode(key, val, count) {
-        return new TreeMultisetNode(key, val, count);
+    createNode(key, value, count) {
+        return new TreeMultisetNode(key, value, count);
     }
     /**
      * The `add` function adds a new node to a binary search tree, updating the count if the key already
@@ -55,27 +55,27 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
      * `BTNKey` (which represents the key of the node to be added), a `N` (which represents a
      * node to be added), or `null` (which represents a null node).
-     * @param [val] - The `val` parameter represents the value associated with the key that is being
+     * @param [value] - The `value` parameter represents the value associated with the key that is being
      * added to the binary tree.
      * @param [count=1] - The `count` parameter represents the number of occurrences of the key/value
      * pair that will be added to the binary tree. It has a default value of 1, which means that if no
      * count is specified, the default count will be 1.
      * @returns The function `add` returns a value of type `N | null | undefined`.
      */
-    add(keyOrNode, val, count = 1) {
+    add(keyOrNode, value, count = 1) {
         let inserted = undefined, newNode;
         if (keyOrNode instanceof TreeMultisetNode) {
-            newNode = this.createNode(keyOrNode.key, keyOrNode.val, keyOrNode.count);
+            newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
         }
         else if (keyOrNode === null) {
             newNode = null;
         }
         else {
-            newNode = this.createNode(keyOrNode, val, count);
+            newNode = this.createNode(keyOrNode, value, count);
         }
         if (!this.root) {
             this._setRoot(newNode);
-            this._setSize(this.size + 1);
+            this._size = this.size + 1;
             newNode && this._setCount(this.count + newNode.count);
             inserted = this.root;
         }
@@ -86,7 +86,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                 if (cur) {
                     if (newNode) {
                         if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
-                            cur.val = newNode.val;
+                            cur.value = newNode.value;
                             cur.count += newNode.count;
                             this._setCount(this.count + newNode.count);
                             traversing = false;
@@ -97,7 +97,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                             if (cur.left === undefined) {
                                 //Add to the left of the current node
                                 cur.left = newNode;
-                                this._setSize(this.size + 1);
+                                this._size = this.size + 1;
                                 this._setCount(this.count + newNode.count);
                                 traversing = false;
                                 inserted = cur.left;
@@ -113,7 +113,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                             if (cur.right === undefined) {
                                 //Add to the right of the current node
                                 cur.right = newNode;
-                                this._setSize(this.size + 1);
+                                this._size = this.size + 1;
                                 this._setCount(this.count + newNode.count);
                                 traversing = false;
                                 inserted = cur.right;
@@ -151,7 +151,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             if (parent.left === undefined) {
                 parent.left = newNode;
                 if (newNode !== null) {
-                    this._setSize(this.size + 1);
+                    this._size = this.size + 1;
                     this._setCount(this.count + newNode.count);
                 }
                 return parent.left;
@@ -159,7 +159,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             else if (parent.right === undefined) {
                 parent.right = newNode;
                 if (newNode !== null) {
-                    this._setSize(this.size + 1);
+                    this._size = (this.size + 1);
                     this._setCount(this.count + newNode.count);
                 }
                 return parent.right;
@@ -187,7 +187,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         for (let i = 0; i < keysOrNodes.length; i++) {
             const keyOrNode = keysOrNodes[i];
             if (keyOrNode instanceof TreeMultisetNode) {
-                inserted.push(this.add(keyOrNode.key, keyOrNode.val, keyOrNode.count));
+                inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count));
                 continue;
             }
             if (keyOrNode === null) {
@@ -217,7 +217,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add(midNode.key, midNode.val, midNode.count);
+                this.add(midNode.key, midNode.value, midNode.count);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -233,7 +233,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add(midNode.key, midNode.val, midNode.count);
+                        this.add(midNode.key, midNode.value, midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -304,7 +304,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                     }
                 }
             }
-            this._setSize(this.size - 1);
+            this._size = this.size - 1;
             // TODO How to handle when the count of target node is lesser than current node's count
             this._setCount(this.count - orgCurrent.count);
         }
@@ -329,16 +329,16 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * @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);
+        const { key, value, count, height } = destNode;
+        const tempNode = this.createNode(key, value, count);
         if (tempNode) {
             tempNode.height = height;
             destNode.key = srcNode.key;
-            destNode.val = srcNode.val;
+            destNode.value = srcNode.value;
             destNode.count = srcNode.count;
             destNode.height = srcNode.height;
             srcNode.key = tempNode.key;
-            srcNode.val = tempNode.val;
+            srcNode.value = tempNode.value;
             srcNode.count = tempNode.count;
             srcNode.height = tempNode.height;
         }

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

@@ -1,70 +1,52 @@
 import type { DijkstraResult, VertexKey } from '../../types';
 import { IGraph } from '../../interfaces';
 export declare abstract class AbstractVertex<V = any> {
+    key: VertexKey;
+    value: V | undefined;
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
      * @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 object.
-     * @param {V} [val] - The parameter "val" is an optional parameter of type V. It is used to assign a value to the
+     * @param {V} [value] - The parameter "value" is an optional parameter of type V. It is used to assign a value to the
      * vertex. If no value is provided, it will be set to undefined.
      */
-    protected constructor(key: VertexKey, val?: V);
-    private _key;
-    get key(): VertexKey;
-    set key(v: VertexKey);
-    private _val;
-    get val(): V | undefined;
-    set val(value: V | undefined);
+    protected constructor(key: VertexKey, value?: V);
 }
-export declare abstract class AbstractEdge<VO = any> {
+export declare abstract class AbstractEdge<E = any> {
+    value: E | undefined;
+    weight: number;
     /**
      * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
      * object.
      * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the object. If
      * a value is provided, it will be assigned to the `_weight` property. If no value is provided, the default value of 1
      * will be assigned.
-     * @param {VO} [val] - The `val` parameter is of type `VO`, which means it can be any type. It is an optional parameter,
+     * @param {VO} [value] - The `value` parameter is of type `VO`, which means it can be any type. It is an optional parameter,
      * meaning it can be omitted when creating an instance of the class.
      */
-    protected constructor(weight?: number, val?: VO);
-    private _val;
-    get val(): VO | undefined;
-    set val(value: VO | undefined);
-    private _weight;
-    get weight(): number;
-    set weight(v: number);
+    protected constructor(weight?: number, value?: E);
     protected _hashCode: string;
     get hashCode(): string;
-    /**
-     * 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.
-     * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
-     */
-    /**
-     * The function sets the value of the _hashCode property to the provided string.
-     * @param {string} v - The parameter "v" is of type string and represents the value that will be assigned to the
-     * "_hashCode" property.
-     */
-    protected _setHashCode(v: string): void;
 }
 export declare abstract class AbstractGraph<V = any, E = any, VO extends AbstractVertex<V> = AbstractVertex<V>, EO extends AbstractEdge<E> = AbstractEdge<E>> implements IGraph<V, E, VO, EO> {
-    private _vertices;
+    protected _vertices: Map<VertexKey, VO>;
     get vertices(): Map<VertexKey, VO>;
     /**
      * 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.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
      * @param key
-     * @param val
+     * @param value
      */
-    abstract createVertex(key: VertexKey, val?: V): VO;
+    abstract createVertex(key: VertexKey, value?: V): VO;
     /**
      * 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.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
      * @param srcOrV1
      * @param destOrV2
      * @param weight
-     * @param val
+     * @param value
      */
-    abstract createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): EO;
+    abstract createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
     abstract deleteEdge(edge: EO): EO | null;
     abstract getEdge(srcOrKey: VO | VertexKey, destOrKey: VO | VertexKey): EO | null;
     abstract degreeOf(vertexOrKey: VO | VertexKey): number;
@@ -88,7 +70,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      */
     hasVertex(vertexOrKey: VO | VertexKey): boolean;
     addVertex(vertex: VO): boolean;
-    addVertex(key: VertexKey, val?: V): boolean;
+    addVertex(key: VertexKey, value?: V): boolean;
     /**
      * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
      * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
@@ -114,7 +96,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      */
     hasEdge(v1: VertexKey | VO, v2: VertexKey | VO): boolean;
     addEdge(edge: EO): boolean;
-    addEdge(src: VO | VertexKey, dest: VO | VertexKey, weight?: number, val?: E): boolean;
+    addEdge(src: VO | VertexKey, dest: VO | VertexKey, weight?: number, value?: E): boolean;
     /**
      * The function sets the weight of an edge between two vertices in a graph.
      * @param {VertexKey | VO} srcOrKey - The `srcOrKey` parameter can be either a `VertexKey` or a `VO` object. It represents
@@ -328,5 +310,4 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
     protected _addVertexOnly(newVertex: VO): boolean;
     protected _getVertex(vertexOrKey: VertexKey | VO): VO | null;
     protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey;
-    protected _setVertices(value: Map<VertexKey, VO>): void;
 }