@monstermann/graph 0.0.0 → 0.1.0

package/dist/Graph/index.mjs

@@ -0,0 +1,65 @@
+import { batch } from "./batch.mjs";
+import { create } from "./create.mjs";
+import { findEdge } from "./findEdge.mjs";
+import { findEdges } from "./findEdges.mjs";
+import { getNode } from "./getNode.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 { hasNode } from "./hasNode.mjs";
+import { setEdge } from "./setEdge.mjs";
+import { setNode } from "./setNode.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 { getNodes } from "./getNodes.mjs";
+import { hasEdge } from "./hasEdge.mjs";
+import { mapEdge } from "./mapEdge.mjs";
+import { removeNode } from "./removeNode.mjs";
+import { mapNode } from "./mapNode.mjs";
+import { mergeEdge } from "./mergeEdge.mjs";
+import { mergeNode } from "./mergeNode.mjs";
+import { removeEdge } from "./removeEdge.mjs";
+import { toJS } from "./toJS.mjs";
+
+//#region src/Graph/index.js
+const Graph = {
+	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 { Graph };

package/dist/Graph/internals/core.mjs

@@ -0,0 +1,51 @@
+//#region src/Graph/internals/core.ts
+function setInGraph(graph, path, value) {
+	return setInMap(graph.get("clones"), graph, path, value);
+}
+function unsetInGraph(graph, path) {
+	return unsetInMap(graph.get("clones"), graph, path);
+}
+const emptyMap = /* @__PURE__ */ new Map();
+function setInMap(clones, map, path, value, offset = 0) {
+	if (path.length === 0) return map;
+	const key = path[offset];
+	if (offset === path.length - 1) return set(map, key, value, clones);
+	return set(map, key, setInMap(clones, map.get(key) ?? createMap(clones), path, value, offset + 1), clones);
+}
+function unsetInMap(clones, map, path, offset = 0) {
+	if (path.length === 0) return emptyMap;
+	const key = path[offset];
+	const isLast = offset === path.length - 1;
+	if (!map.has(key)) return map;
+	if (isLast) return unset(map, key, clones);
+	const child = unsetInMap(clones, map.get(key), path, offset + 1);
+	if (child.size === 0) return unset(map, key, clones);
+	return set(map, key, child, clones);
+}
+function createMap(clones) {
+	const map = /* @__PURE__ */ new Map();
+	clones?.add(map);
+	return map;
+}
+function set(map, key, value, clones) {
+	if (map.get(key) === value) return map;
+	const clone = cloneMap(map, clones);
+	clone.set(key, value);
+	return clone;
+}
+function unset(map, key, clones) {
+	if (map.size === 1) return emptyMap;
+	const clone = cloneMap(map, clones);
+	clone.delete(key);
+	return clone;
+}
+function cloneMap(target, clones) {
+	if (!clones) return new Map(target);
+	if (clones.has(target)) return target;
+	const clone = new Map(target);
+	clones.add(clone);
+	return clone;
+}
+
+//#endregion
+export { setInGraph, unsetInGraph };

package/dist/Graph/internals/parseNodeIdentifier.mjs

@@ -0,0 +1,7 @@
+//#region src/Graph/internals/parseNodeIdentifier.ts
+function parseNodeIdentifier(identifier) {
+	return Array.isArray(identifier) ? identifier : [identifier.type, identifier.id];
+}
+
+//#endregion
+export { parseNodeIdentifier };

package/dist/Graph/internals/types.d.mts

@@ -0,0 +1,16 @@
+import { Edge, Node, NodeId, NodeOfType, NodeType } from "../types.mjs";
+
+//#region src/Graph/internals/types.d.ts
+type GetAllTargets<E> = E extends Record<string, infer V> ? V extends Record<string, any> ? keyof V : never : never;
+type GetReverseMappings<E, Target> = { [K in keyof E as Target extends keyof E[K] ? K : never]: E[K][Target & keyof E[K]] };
+type Bimap<E> = { [K in keyof E | GetAllTargets<E>]: (K extends keyof E ? E[K] : {}) & GetReverseMappings<E, K> };
+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$1 extends NodeType<T>>(type: V$1) => NodeIdsMap<T, V$1> | undefined;
+}
+//#endregion
+export { Bimap, NodeTypesMap, SourceTypesMap };

package/dist/Graph/mapEdge.d.mts

@@ -0,0 +1,53 @@
+import { Bimap } from "./internals/types.mjs";
+import { Edges, Graph, Node, NodeIdentifier, NodeType } from "./types.mjs";
+
+//#region src/Graph/mapEdge.d.ts
+
+/**
+ * # mapEdge
+ *
+ * ```ts
+ * function Graph.mapEdge(
+ *     graph: Graph,
+ *     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     target: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     update: (edge: EdgeData) => EdgeData,
+ * ): Graph
+ * ```
+ *
+ * Updates an edge by applying a transformation function. Returns a new graph instance with the updated edge.
+ *
+ * ## 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: { priority: number; assignedAt: Date } };
+ *     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"], {
+ *     priority: 1,
+ *     assignedAt: new Date(),
+ * });
+ *
+ * // Update edge data
+ * g = Graph.mapEdge(g, ["Project", "1"], ["Task", "1"], (edge) => ({
+ *     ...edge,
+ *     priority: 2,
+ * }));
+ * ```
+ *
+ */
+declare function mapEdge<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>, update: (edge: NoInfer<Bimap<E>[N1][N2]>) => NoInfer<Bimap<E>[N1][N2]>): Graph<N, E>;
+//#endregion
+export { mapEdge };

package/dist/Graph/mapEdge.mjs

@@ -0,0 +1,60 @@
+import { setEdge } from "./setEdge.mjs";
+import { getEdge } from "./getEdge.mjs";
+import { hasEdge } from "./hasEdge.mjs";
+
+//#region src/Graph/mapEdge.ts
+/**
+* # mapEdge
+*
+* ```ts
+* function Graph.mapEdge(
+*     graph: Graph,
+*     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     target: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     update: (edge: EdgeData) => EdgeData,
+* ): Graph
+* ```
+*
+* Updates an edge by applying a transformation function. Returns a new graph instance with the updated edge.
+*
+* ## 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: { priority: number; assignedAt: Date } };
+*     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"], {
+*     priority: 1,
+*     assignedAt: new Date(),
+* });
+*
+* // Update edge data
+* g = Graph.mapEdge(g, ["Project", "1"], ["Task", "1"], (edge) => ({
+*     ...edge,
+*     priority: 2,
+* }));
+* ```
+*
+*/
+function mapEdge(graph, source, target, update) {
+	if (!hasEdge(graph, source, target)) return graph;
+	const before = getEdge(graph, source, target);
+	const after = update(before);
+	if (before === after) return graph;
+	return setEdge(graph, source, target, after);
+}
+
+//#endregion
+export { mapEdge };

package/dist/Graph/mapNode.d.mts

@@ -0,0 +1,66 @@
+import { Edges, Graph, Node, NodeIdentifier, NodeOfType, NodeType } from "./types.mjs";
+
+//#region src/Graph/mapNode.d.ts
+
+/**
+ * # mapNode
+ *
+ * ```ts
+ * function Graph.mapNode(
+ *     graph: Graph,
+ *     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     update: (node: Node) => Node,
+ * ): Graph
+ * ```
+ *
+ * Updates a node by applying a transformation function. If the node's type or id changes, all edges are preserved. Returns a new graph instance with the updated node.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string; title: string; completed: boolean }
+ *     | { 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: "My Task",
+ *     completed: false,
+ * });
+ *
+ * // Update a property
+ * g = Graph.mapNode(g, ["Task", "1"], (task) => ({
+ *     ...task,
+ *     completed: true,
+ * }));
+ *
+ * // Change id (edges are preserved)
+ * let g2 = Graph.setNode(graph, {
+ *     type: "Task",
+ *     id: "1",
+ *     title: "Task",
+ *     completed: false,
+ * });
+ * g2 = Graph.setNode(g2, { type: "Project", id: "1" });
+ * g2 = Graph.setEdge(g2, ["Project", "1"], ["Task", "1"]);
+ * g2 = Graph.mapNode(g2, ["Task", "1"], (task) => ({
+ *     ...task,
+ *     id: "2",
+ * }));
+ * // Edge now connects ["Project", "1"] -> ["Task", "2"]
+ * ```
+ *
+ */
+declare function mapNode<N extends Node, E extends Edges<N>, U extends NodeType<N>>(graph: Graph<N, E>, node: NodeIdentifier<N, U>, update: (node: NoInfer<NodeOfType<N, U>>) => NoInfer<NodeOfType<N, U>>): Graph<N, E>;
+//#endregion
+export { mapNode };

package/dist/Graph/mapNode.mjs

@@ -0,0 +1,83 @@
+import { batch } from "./batch.mjs";
+import { getNode } from "./getNode.mjs";
+import { setEdge } from "./setEdge.mjs";
+import { setNode } from "./setNode.mjs";
+import { removeNode } from "./removeNode.mjs";
+
+//#region src/Graph/mapNode.ts
+/**
+* # mapNode
+*
+* ```ts
+* function Graph.mapNode(
+*     graph: Graph,
+*     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     update: (node: Node) => Node,
+* ): Graph
+* ```
+*
+* Updates a node by applying a transformation function. If the node's type or id changes, all edges are preserved. Returns a new graph instance with the updated node.
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string; title: string; completed: boolean }
+*     | { 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: "My Task",
+*     completed: false,
+* });
+*
+* // Update a property
+* g = Graph.mapNode(g, ["Task", "1"], (task) => ({
+*     ...task,
+*     completed: true,
+* }));
+*
+* // Change id (edges are preserved)
+* let g2 = Graph.setNode(graph, {
+*     type: "Task",
+*     id: "1",
+*     title: "Task",
+*     completed: false,
+* });
+* g2 = Graph.setNode(g2, { type: "Project", id: "1" });
+* g2 = Graph.setEdge(g2, ["Project", "1"], ["Task", "1"]);
+* g2 = Graph.mapNode(g2, ["Task", "1"], (task) => ({
+*     ...task,
+*     id: "2",
+* }));
+* // Edge now connects ["Project", "1"] -> ["Task", "2"]
+* ```
+*
+*/
+function mapNode(graph, node, update) {
+	const prev = getNode(graph, node);
+	if (!prev) return graph;
+	const next = update(prev);
+	if (prev === next) return graph;
+	if (prev.id === next.id && prev.type === next.type) return setNode(graph, next);
+	return batch(graph, (graph$1) => {
+		graph$1 = setNode(graph$1, next);
+		const edges = graph$1.get("edges");
+		for (const [targetType, targetIds] of edges?.get(prev.type)?.get(prev.id) ?? []) for (const [targetId, targetData] of targetIds) graph$1 = setEdge(graph$1, [next.type, next.id], [targetType, targetId], targetData);
+		graph$1 = removeNode(graph$1, prev);
+		return graph$1;
+	});
+}
+
+//#endregion
+export { mapNode };

package/dist/Graph/mergeEdge.d.mts

@@ -0,0 +1,53 @@
+import { Bimap } from "./internals/types.mjs";
+import { Edges, Graph, Node, NodeIdentifier, NodeType } from "./types.mjs";
+
+//#region src/Graph/mergeEdge.d.ts
+
+/**
+ * # mergeEdge
+ *
+ * ```ts
+ * function Graph.mergeEdge(
+ *     graph: Graph,
+ *     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     target: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     update: Partial<EdgeData>,
+ * ): Graph
+ * ```
+ *
+ * Partially updates an edge by merging the provided properties. Returns a new graph instance with the updated edge.
+ *
+ * ## 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: { priority: number; assignedAt: Date } };
+ *     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"], {
+ *     priority: 1,
+ *     assignedAt: new Date(),
+ * });
+ *
+ * // Merge partial update
+ * g = Graph.mergeEdge(g, ["Project", "1"], ["Task", "1"], { priority: 2 });
+ *
+ * const edge = Graph.getEdge(g, ["Project", "1"], ["Task", "1"]);
+ * // edge: { priority: 2, assignedAt: <original date> }
+ * ```
+ *
+ */
+declare function mergeEdge<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>, update: Partial<Bimap<E>[N1][N2]>): Graph<N, E>;
+//#endregion
+export { mergeEdge };

package/dist/Graph/mergeEdge.mjs

@@ -0,0 +1,63 @@
+import { setEdge } from "./setEdge.mjs";
+import { getEdge } from "./getEdge.mjs";
+import { hasEdge } from "./hasEdge.mjs";
+
+//#region src/Graph/mergeEdge.ts
+/**
+* # mergeEdge
+*
+* ```ts
+* function Graph.mergeEdge(
+*     graph: Graph,
+*     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     target: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     update: Partial<EdgeData>,
+* ): Graph
+* ```
+*
+* Partially updates an edge by merging the provided properties. Returns a new graph instance with the updated edge.
+*
+* ## 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: { priority: number; assignedAt: Date } };
+*     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"], {
+*     priority: 1,
+*     assignedAt: new Date(),
+* });
+*
+* // Merge partial update
+* g = Graph.mergeEdge(g, ["Project", "1"], ["Task", "1"], { priority: 2 });
+*
+* const edge = Graph.getEdge(g, ["Project", "1"], ["Task", "1"]);
+* // edge: { priority: 2, assignedAt: <original date> }
+* ```
+*
+*/
+function mergeEdge(graph, source, target, update) {
+	if (!hasEdge(graph, source, target)) return graph;
+	const edge = getEdge(graph, source, target);
+	const keys = Object.keys(update);
+	if (keys.length === 0) return graph;
+	return keys.some((k) => update[k] !== edge[k]) ? setEdge(graph, source, target, {
+		...edge,
+		...update
+	}) : graph;
+}
+
+//#endregion
+export { mergeEdge };

package/dist/Graph/mergeNode.d.mts

@@ -0,0 +1,51 @@
+import { Edges, Graph, Node, NodeIdentifier, NodeOfType, NodeType } from "./types.mjs";
+
+//#region src/Graph/mergeNode.d.ts
+
+/**
+ * # mergeNode
+ *
+ * ```ts
+ * function Graph.mergeNode(
+ *     graph: Graph,
+ *     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     update: Partial<Node>,
+ * ): Graph
+ * ```
+ *
+ * Partially updates a node by merging the provided properties. Returns a new graph instance with the updated node.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { Graph } from "@monstermann/graph";
+ *
+ * type Nodes =
+ *     | { type: "Task"; id: string; title: string; completed: boolean }
+ *     | { 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: "My Task",
+ *     completed: false,
+ * });
+ *
+ * // Merge partial update
+ * g = Graph.mergeNode(g, ["Task", "1"], { completed: true });
+ *
+ * const task = Graph.getNode(g, ["Task", "1"]);
+ * // task: { type: "Task", id: "1", title: "My Task", completed: true }
+ * ```
+ *
+ */
+declare function mergeNode<N extends Node, E extends Edges<N>, U extends NodeType<N>>(graph: Graph<N, E>, node: NodeIdentifier<N, U>, update: Partial<NodeOfType<N, U>>): Graph<N, E>;
+//#endregion
+export { mergeNode };

package/dist/Graph/mergeNode.mjs

@@ -0,0 +1,60 @@
+import { mapNode } from "./mapNode.mjs";
+
+//#region src/Graph/mergeNode.ts
+/**
+* # mergeNode
+*
+* ```ts
+* function Graph.mergeNode(
+*     graph: Graph,
+*     node: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+*     update: Partial<Node>,
+* ): Graph
+* ```
+*
+* Partially updates a node by merging the provided properties. Returns a new graph instance with the updated node.
+*
+* ## Example
+*
+* ```ts
+* import { Graph } from "@monstermann/graph";
+*
+* type Nodes =
+*     | { type: "Task"; id: string; title: string; completed: boolean }
+*     | { 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: "My Task",
+*     completed: false,
+* });
+*
+* // Merge partial update
+* g = Graph.mergeNode(g, ["Task", "1"], { completed: true });
+*
+* const task = Graph.getNode(g, ["Task", "1"]);
+* // task: { type: "Task", id: "1", title: "My Task", completed: true }
+* ```
+*
+*/
+function mergeNode(graph, node, update) {
+	return mapNode(graph, node, (node$1) => {
+		const keys = Object.keys(update);
+		if (keys.length === 0) return node$1;
+		return keys.some((k) => update[k] !== node$1[k]) ? {
+			...node$1,
+			...update
+		} : node$1;
+	});
+}
+
+//#endregion
+export { mergeNode };

package/dist/Graph/removeEdge.d.mts

@@ -0,0 +1,50 @@
+import { Bimap } from "./internals/types.mjs";
+import { Edges, Graph, Node, NodeIdentifier, NodeType } from "./types.mjs";
+
+//#region src/Graph/removeEdge.d.ts
+
+/**
+ * # removeEdge
+ *
+ * ```ts
+ * function Graph.removeEdge(
+ *     graph: Graph,
+ *     source: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ *     target: [NodeType, NodeId] | { type: NodeType, id: NodeId },
+ * ): Graph
+ * ```
+ *
+ * Removes an edge between two nodes. The nodes remain in the graph. Returns a new graph instance without the edge.
+ *
+ * ## 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"]);
+ *
+ * // Remove the edge
+ * g = Graph.removeEdge(g, ["Project", "1"], ["Task", "1"]);
+ *
+ * Graph.hasNode(g, ["Project", "1"]); // true
+ * Graph.hasNode(g, ["Task", "1"]); // true
+ * Graph.hasEdge(g, ["Project", "1"], ["Task", "1"]); // false
+ * ```
+ *
+ */
+declare function removeEdge<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>): Graph<N, E>;
+//#endregion
+export { removeEdge };