@monstermann/graph 0.0.0 → 0.2.0

package/dist/Graph/getNeighbor.d.mts

@@ -0,0 +1,50 @@
+import { Bimap } from "./internals/types.mjs";
+import { Edges, Graph, Node, NodeIdentifier, NodeOfType, NodeType } from "./types.mjs";
+
+//#region src/Graph/getNeighbor.d.ts
+/**
+ * # getNeighbor
+ *
+ * ```ts
+ * function Graph.getNeighbor(
+ *     graph: Graph,
+ *     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     type: NodeType,
+ * ): Node | undefined
+ * ```
+ *
+ * Retrieves the first neighbor node of a specific type connected to the source node. Returns `undefined` if no neighbor of the specified type exists.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string; title: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string };
+ *
+ * type Edges = {
+ *     Project: { Task: void };
+ *     Section: { Task: void };
+ * };
+ *
+ * const graph = Graph.create<Nodes, Edges>();
+ * let g = Graph.setNode(graph, { type: "Project", id: "1" });
+ * g = Graph.setNode(g, { type: "Task", id: "1", title: "Task 1" });
+ * g = Graph.setNode(g, { type: "Task", id: "2", title: "Task 2" });
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"]);
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "2"]);
+ *
+ * const firstTask = Graph.getNeighbor(g, ["Project", "1"], "Task");
+ * // firstTask: { type: "Task", id: "1", title: "Task 1" }
+ *
+ * const noSection = Graph.getNeighbor(g, ["Project", "1"], "Section");
+ * // noSection: undefined
+ * ```
+ *
+ */
+declare function getNeighbor<N extends Node, E extends Edges<N>, N1 extends NodeType<N>, N2 extends keyof Bimap<E>[N1] & NodeType<N>>(graph: Graph<N, E>, node: NodeIdentifier<N, N1>, type: N2): NodeOfType<N, N2> | undefined;
+//#endregion
+export { getNeighbor };

package/dist/Graph/getNeighbor.mjs

@@ -0,0 +1,56 @@
+import { getNode } from "./getNode.mjs";
+
+//#region src/Graph/getNeighbor.ts
+/**
+* # getNeighbor
+*
+* ```ts
+* function Graph.getNeighbor(
+*     graph: Graph,
+*     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     type: NodeType,
+* ): Node | undefined
+* ```
+*
+* Retrieves the first neighbor node of a specific type connected to the source node. Returns `undefined` if no neighbor of the specified type exists.
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string; title: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string };
+*
+* type Edges = {
+*     Project: { Task: void };
+*     Section: { Task: void };
+* };
+*
+* const graph = Graph.create<Nodes, Edges>();
+* let g = Graph.setNode(graph, { type: "Project", id: "1" });
+* g = Graph.setNode(g, { type: "Task", id: "1", title: "Task 1" });
+* g = Graph.setNode(g, { type: "Task", id: "2", title: "Task 2" });
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"]);
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "2"]);
+*
+* const firstTask = Graph.getNeighbor(g, ["Project", "1"], "Task");
+* // firstTask: { type: "Task", id: "1", title: "Task 1" }
+*
+* const noSection = Graph.getNeighbor(g, ["Project", "1"], "Section");
+* // noSection: undefined
+* ```
+*
+*/
+function getNeighbor(graph, node, type) {
+	const sourceNode = getNode(graph, node);
+	if (!sourceNode) return void 0;
+	const nodeMap = graph.get("nodes")?.get(type);
+	if (!nodeMap) return void 0;
+	for (const targetId of graph.get("edges")?.get(sourceNode.type)?.get(sourceNode.id)?.get(type)?.keys() ?? []) return nodeMap.get(targetId);
+}
+
+//#endregion
+export { getNeighbor };

package/dist/Graph/getNeighbors.d.mts

@@ -0,0 +1,47 @@
+import { Bimap } from "./internals/types.mjs";
+import { Edges, Graph, Node, NodeIdentifier, NodeOfType, NodeType } from "./types.mjs";
+
+//#region src/Graph/getNeighbors.d.ts
+/**
+ * # getNeighbors
+ *
+ * ```ts
+ * function Graph.getNeighbors(
+ *     graph: Graph,
+ *     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     type: NodeType,
+ * ): Node[]
+ * ```
+ *
+ * Retrieves all neighbor nodes of a specific type connected to the source node.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string; title: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string };
+ *
+ * type Edges = {
+ *     Project: { Task: void };
+ *     Section: { Task: void };
+ * };
+ *
+ * const graph = Graph.create<Nodes, Edges>();
+ * let g = Graph.setNode(graph, { type: "Project", id: "1" });
+ * g = Graph.setNode(g, { type: "Task", id: "1", title: "Task 1" });
+ * g = Graph.setNode(g, { type: "Task", id: "2", title: "Task 2" });
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"]);
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "2"]);
+ *
+ * const tasks = Graph.getNeighbors(g, ["Project", "1"], "Task");
+ * // tasks: [{ type: "Task", id: "1", title: "Task 1" }, { type: "Task", id: "2", title: "Task 2" }]
+ * ```
+ *
+ */
+declare function getNeighbors<N extends Node, E extends Edges<N>, N1 extends NodeType<N>, N2 extends keyof Bimap<E>[N1] & NodeType<N>>(graph: Graph<N, E>, node: NodeIdentifier<N, N1>, type: N2): NodeOfType<N, N2>[];
+//#endregion
+export { getNeighbors };

package/dist/Graph/getNeighbors.mjs

@@ -0,0 +1,58 @@
+import { getNode } from "./getNode.mjs";
+
+//#region src/Graph/getNeighbors.ts
+/**
+* # getNeighbors
+*
+* ```ts
+* function Graph.getNeighbors(
+*     graph: Graph,
+*     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     type: NodeType,
+* ): Node[]
+* ```
+*
+* Retrieves all neighbor nodes of a specific type connected to the source node.
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string; title: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string };
+*
+* type Edges = {
+*     Project: { Task: void };
+*     Section: { Task: void };
+* };
+*
+* const graph = Graph.create<Nodes, Edges>();
+* let g = Graph.setNode(graph, { type: "Project", id: "1" });
+* g = Graph.setNode(g, { type: "Task", id: "1", title: "Task 1" });
+* g = Graph.setNode(g, { type: "Task", id: "2", title: "Task 2" });
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"]);
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "2"]);
+*
+* const tasks = Graph.getNeighbors(g, ["Project", "1"], "Task");
+* // tasks: [{ type: "Task", id: "1", title: "Task 1" }, { type: "Task", id: "2", title: "Task 2" }]
+* ```
+*
+*/
+function getNeighbors(graph, node, type) {
+	const result = [];
+	const sourceNode = getNode(graph, node);
+	if (!sourceNode) return result;
+	const nodeMap = graph.get("nodes")?.get(type);
+	if (!nodeMap) return result;
+	for (const targetId of graph.get("edges")?.get(sourceNode.type)?.get(sourceNode.id)?.get(type)?.keys() ?? []) {
+		const targetNode = nodeMap.get(targetId);
+		result.push(targetNode);
+	}
+	return result;
+}
+
+//#endregion
+export { getNeighbors };

package/dist/Graph/getNode.d.mts

@@ -0,0 +1,48 @@
+import { Edges, Graph, Node, NodeIdentifier, NodeOfType, NodeType } from "./types.mjs";
+
+//#region src/Graph/getNode.d.ts
+/**
+ * # getNode
+ *
+ * ```ts
+ * function Graph.getNode(
+ *     graph: Graph,
+ *     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ * ): Node | undefined
+ * ```
+ *
+ * Retrieves a node from the graph. Returns `undefined` if the node doesn't exist.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string; title: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string };
+ *
+ * type Edges = {
+ *     Project: { Task: void };
+ *     Section: { Task: void };
+ * };
+ *
+ * const graph = Graph.create<Nodes, Edges>();
+ * const withNode = Graph.setNode(graph, {
+ *     type: "Task",
+ *     id: "1",
+ *     title: "My Task",
+ * });
+ *
+ * const task = Graph.getNode(withNode, ["Task", "1"]);
+ * // task: { type: "Task", id: "1", title: "My Task" }
+ *
+ * const missing = Graph.getNode(withNode, ["Task", "2"]);
+ * // missing: undefined
+ * ```
+ *
+ */
+declare function getNode<N extends Node, E extends Edges<N>, U extends NodeType<N>>(graph: Graph<N, E>, node: NodeIdentifier<N, U>): NodeOfType<N, U> | undefined;
+//#endregion
+export { getNode };

package/dist/Graph/getNode.mjs

@@ -0,0 +1,52 @@
+import { parseNodeIdentifier } from "./internals/parseNodeIdentifier.mjs";
+
+//#region src/Graph/getNode.ts
+/**
+* # getNode
+*
+* ```ts
+* function Graph.getNode(
+*     graph: Graph,
+*     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+* ): Node | undefined
+* ```
+*
+* Retrieves a node from the graph. Returns `undefined` if the node doesn't exist.
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string; title: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string };
+*
+* type Edges = {
+*     Project: { Task: void };
+*     Section: { Task: void };
+* };
+*
+* const graph = Graph.create<Nodes, Edges>();
+* const withNode = Graph.setNode(graph, {
+*     type: "Task",
+*     id: "1",
+*     title: "My Task",
+* });
+*
+* const task = Graph.getNode(withNode, ["Task", "1"]);
+* // task: { type: "Task", id: "1", title: "My Task" }
+*
+* const missing = Graph.getNode(withNode, ["Task", "2"]);
+* // missing: undefined
+* ```
+*
+*/
+function getNode(graph, node) {
+	const [type, id] = parseNodeIdentifier(node);
+	return graph.get("nodes")?.get(type)?.get(id);
+}
+
+//#endregion
+export { getNode };

package/dist/Graph/getNodes.d.mts

@@ -0,0 +1,46 @@
+import { Edges, Graph, Node, NodeOfType, NodeType } from "./types.mjs";
+
+//#region src/Graph/getNodes.d.ts
+/**
+ * # getNodes
+ *
+ * ```ts
+ * function Graph.getNodes(
+ *     graph: Graph,
+ *     type: NodeType,
+ * ): Node[]
+ * ```
+ *
+ * Retrieves all nodes of a specific type from the graph.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string; title: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string };
+ *
+ * type Edges = {
+ *     Project: { Task: void };
+ *     Section: { Task: void };
+ * };
+ *
+ * const graph = Graph.create<Nodes, Edges>();
+ * let g = Graph.setNode(graph, { type: "Task", id: "1", title: "Task 1" });
+ * g = Graph.setNode(g, { type: "Task", id: "2", title: "Task 2" });
+ * g = Graph.setNode(g, { type: "Project", id: "1" });
+ *
+ * const tasks = Graph.getNodes(g, "Task");
+ * // tasks: [{ type: "Task", id: "1", title: "Task 1" }, { type: "Task", id: "2", title: "Task 2" }]
+ *
+ * const projects = Graph.getNodes(g, "Project");
+ * // projects: [{ type: "Project", id: "1" }]
+ * ```
+ *
+ */
+declare function getNodes<N extends Node, E extends Edges<N>, U extends NodeType<N>>(graph: Graph<N, E>, type: U): NodeOfType<N, U>[];
+//#endregion
+export { getNodes };

package/dist/Graph/getNodes.mjs

@@ -0,0 +1,48 @@
+//#region src/Graph/getNodes.ts
+/**
+* # getNodes
+*
+* ```ts
+* function Graph.getNodes(
+*     graph: Graph,
+*     type: NodeType,
+* ): Node[]
+* ```
+*
+* Retrieves all nodes of a specific type from the graph.
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string; title: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string };
+*
+* type Edges = {
+*     Project: { Task: void };
+*     Section: { Task: void };
+* };
+*
+* const graph = Graph.create<Nodes, Edges>();
+* let g = Graph.setNode(graph, { type: "Task", id: "1", title: "Task 1" });
+* g = Graph.setNode(g, { type: "Task", id: "2", title: "Task 2" });
+* g = Graph.setNode(g, { type: "Project", id: "1" });
+*
+* const tasks = Graph.getNodes(g, "Task");
+* // tasks: [{ type: "Task", id: "1", title: "Task 1" }, { type: "Task", id: "2", title: "Task 2" }]
+*
+* const projects = Graph.getNodes(g, "Project");
+* // projects: [{ type: "Project", id: "1" }]
+* ```
+*
+*/
+function getNodes(graph, type) {
+	const nodeMap = graph.get("nodes")?.get(type);
+	return nodeMap ? [...nodeMap.values()] : [];
+}
+
+//#endregion
+export { getNodes };

package/dist/Graph/hasEdge.d.mts

@@ -0,0 +1,46 @@
+import { Bimap } from "./internals/types.mjs";
+import { Edges, Graph, Node, NodeIdentifier, NodeType } from "./types.mjs";
+
+//#region src/Graph/hasEdge.d.ts
+/**
+ * # hasEdge
+ *
+ * ```ts
+ * function Graph.hasEdge(
+ *     graph: Graph,
+ *     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     target: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ * ): boolean
+ * ```
+ *
+ * Checks if an edge exists between two nodes in the graph.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string };
+ *
+ * type Edges = {
+ *     Project: { Task: void };
+ *     Section: { Task: void };
+ * };
+ *
+ * const graph = Graph.create<Nodes, Edges>();
+ * let g = Graph.setNode(graph, { type: "Project", id: "1" });
+ * g = Graph.setNode(g, { type: "Task", id: "1" });
+ * g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"]);
+ *
+ * Graph.hasEdge(g, ["Project", "1"], ["Task", "1"]); // true
+ * Graph.hasEdge(g, ["Task", "1"], ["Project", "1"]); // true (bidirectional)
+ * Graph.hasEdge(g, ["Project", "1"], ["Task", "2"]); // false
+ * ```
+ *
+ */
+declare function hasEdge<N extends Node, E extends Edges<N>, N1 extends keyof Bimap<E> & NodeType<N>, N2 extends keyof Bimap<E>[N1] & NodeType<N>>(graph: Graph<N, E>, source: NodeIdentifier<N, N1>, target: NodeIdentifier<N, N2>): boolean;
+//#endregion
+export { hasEdge };

package/dist/Graph/hasEdge.mjs

@@ -0,0 +1,50 @@
+import { parseNodeIdentifier } from "./internals/parseNodeIdentifier.mjs";
+
+//#region src/Graph/hasEdge.ts
+/**
+* # hasEdge
+*
+* ```ts
+* function Graph.hasEdge(
+*     graph: Graph,
+*     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     target: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+* ): boolean
+* ```
+*
+* Checks if an edge exists between two nodes in the graph.
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string };
+*
+* type Edges = {
+*     Project: { Task: void };
+*     Section: { Task: void };
+* };
+*
+* const graph = Graph.create<Nodes, Edges>();
+* let g = Graph.setNode(graph, { type: "Project", id: "1" });
+* g = Graph.setNode(g, { type: "Task", id: "1" });
+* g = Graph.setEdge(g, ["Project", "1"], ["Task", "1"]);
+*
+* Graph.hasEdge(g, ["Project", "1"], ["Task", "1"]); // true
+* Graph.hasEdge(g, ["Task", "1"], ["Project", "1"]); // true (bidirectional)
+* Graph.hasEdge(g, ["Project", "1"], ["Task", "2"]); // false
+* ```
+*
+*/
+function hasEdge(graph, source, target) {
+	const [sourceType, sourceId] = parseNodeIdentifier(source);
+	const [targetType, targetId] = parseNodeIdentifier(target);
+	return graph.get("edges")?.get(sourceType)?.get(sourceId)?.get(targetType)?.has(targetId) ?? false;
+}
+
+//#endregion
+export { hasEdge };

package/dist/Graph/hasNode.d.mts

@@ -0,0 +1,42 @@
+import { Edges, Graph, Node, NodeIdentifier, NodeType } from "./types.mjs";
+
+//#region src/Graph/hasNode.d.ts
+/**
+ * # hasNode
+ *
+ * ```ts
+ * function Graph.hasNode(
+ *     graph: Graph,
+ *     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ * ): boolean
+ * ```
+ *
+ * Checks if a node exists in the graph.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string }
+ *     | { type: "Section"; id: string }
+ *     | { type: "Project"; id: string };
+ *
+ * type Edges = {
+ *     Project: { Task: void };
+ *     Section: { Task: void };
+ * };
+ *
+ * const graph = Graph.create<Nodes, Edges>();
+ * const withNode = Graph.setNode(graph, { type: "Task", id: "1" });
+ *
+ * Graph.hasNode(withNode, ["Task", "1"]); // true
+ * Graph.hasNode(withNode, { type: "Task", id: "1" }); // true
+ * Graph.hasNode(withNode, ["Task", "2"]); // false
+ * ```
+ *
+ */
+declare function hasNode<N extends Node, E extends Edges<N>, U extends NodeType<N>>(graph: Graph<N, E>, node: NodeIdentifier<N, U>): boolean;
+//#endregion
+export { hasNode };

package/dist/Graph/hasNode.mjs

@@ -0,0 +1,46 @@
+import { parseNodeIdentifier } from "./internals/parseNodeIdentifier.mjs";
+
+//#region src/Graph/hasNode.ts
+/**
+* # hasNode
+*
+* ```ts
+* function Graph.hasNode(
+*     graph: Graph,
+*     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+* ): boolean
+* ```
+*
+* Checks if a node exists in the graph.
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string }
+*     | { type: "Section"; id: string }
+*     | { type: "Project"; id: string };
+*
+* type Edges = {
+*     Project: { Task: void };
+*     Section: { Task: void };
+* };
+*
+* const graph = Graph.create<Nodes, Edges>();
+* const withNode = Graph.setNode(graph, { type: "Task", id: "1" });
+*
+* Graph.hasNode(withNode, ["Task", "1"]); // true
+* Graph.hasNode(withNode, { type: "Task", id: "1" }); // true
+* Graph.hasNode(withNode, ["Task", "2"]); // false
+* ```
+*
+*/
+function hasNode(graph, node) {
+	const [type, id] = parseNodeIdentifier(node);
+	return graph.get("nodes")?.get(type)?.has(id) ?? false;
+}
+
+//#endregion
+export { hasNode };

package/dist/Graph/index.d.mts

@@ -0,0 +1,68 @@
+import { batch } from "./batch.mjs";
+import { create } from "./create.mjs";
+import { findEdge } from "./findEdge.mjs";
+import { findEdges } from "./findEdges.mjs";
+import { findNeighbor } from "./findNeighbor.mjs";
+import { findNeighbors } from "./findNeighbors.mjs";
+import { findNode } from "./findNode.mjs";
+import { findNodes } from "./findNodes.mjs";
+import { forEachEdge } from "./forEachEdge.mjs";
+import { forEachNeighbor } from "./forEachNeighbor.mjs";
+import { forEachNode } from "./forEachNode.mjs";
+import { fromJS } from "./fromJS.mjs";
+import { getEdge } from "./getEdge.mjs";
+import { getEdges } from "./getEdges.mjs";
+import { getNeighbor } from "./getNeighbor.mjs";
+import { getNeighbors } from "./getNeighbors.mjs";
+import { getNode } from "./getNode.mjs";
+import { getNodes } from "./getNodes.mjs";
+import { hasEdge } from "./hasEdge.mjs";
+import { hasNode } from "./hasNode.mjs";
+import { mapEdge } from "./mapEdge.mjs";
+import { mapNode } from "./mapNode.mjs";
+import { mergeEdge } from "./mergeEdge.mjs";
+import { mergeNode } from "./mergeNode.mjs";
+import { removeEdge } from "./removeEdge.mjs";
+import { removeNode } from "./removeNode.mjs";
+import { setEdge } from "./setEdge.mjs";
+import { setNode } from "./setNode.mjs";
+import { toJS } from "./toJS.mjs";
+
+//#region src/Graph/index.d.ts
+type NodeId = PropertyKey;
+type Node = {
+  id: NodeId;
+  type: string;
+};
+type NodeType<T extends Node> = T["type"];
+type NodeOfType<T extends Node, U extends NodeType<T>> = Extract<T, {
+  type: U;
+}>;
+type NodeIdentifier<T extends Node, U = NodeType<T>> = {
+  id: Extract<T, {
+    type: U;
+  }>["id"];
+  type: U;
+} | [U, id: Extract<T, {
+  type: U;
+}>["id"]];
+type Edge = Record<string, unknown> | void;
+type Edges<N extends Node> = Partial<Record<NodeType<N>, Partial<Record<NodeType<N>, Edge>>>>;
+type SourceTypesMap = ReadonlyMap<any, SourceIdsMap>;
+type SourceIdsMap = ReadonlyMap<NodeId, TargetTypesMap>;
+type TargetTypesMap = ReadonlyMap<any, TargetIdsMap>;
+type TargetIdsMap = ReadonlyMap<NodeId, Edge>;
+type NodeIdsMap<T extends Node, U extends NodeType<T> = NodeType<T>> = ReadonlyMap<NodeId, NodeOfType<T, U>>;
+interface NodeTypesMap<T extends Node> extends ReadonlyMap<NodeType<T>, NodeIdsMap<T, NodeType<T>>> {
+  get: <V extends NodeType<T>>(type: V) => NodeIdsMap<T, V> | undefined;
+}
+interface Graph<N extends Node, _E extends Edges<N>> extends Map<"nodes" | "edges" | "clones", NodeTypesMap<N> | SourceTypesMap | Set<any>> {
+  delete: (key: "clones") => boolean;
+  get: ((key: "nodes") => NodeTypesMap<N> | undefined) & ((key: "edges") => SourceTypesMap | undefined) & ((key: "clones") => Set<any> | undefined);
+  set: (key: "clones", value: Set<any>) => this;
+}
+declare namespace Graph {
+  export { batch, create, findEdge, findEdges, findNeighbor, findNeighbors, findNode, findNodes, forEachEdge, forEachNeighbor, forEachNode, fromJS, getEdge, getEdges, getNeighbor, getNeighbors, getNode, getNodes, hasEdge, hasNode, mapEdge, mapNode, mergeEdge, mergeNode, removeEdge, removeNode, setEdge, setNode, toJS };
+}
+//#endregion
+export { Edge, Edges, Graph, Node, NodeId, NodeIdentifier, NodeIdsMap, NodeOfType, NodeType, NodeTypesMap, SourceIdsMap, SourceTypesMap, TargetIdsMap, TargetTypesMap };