@statelyai/graph 0.7.0 → 0.9.0

package/dist/algorithms-g2uWmPrb.d.mts

@@ -0,0 +1,786 @@
+import { A as TraversalOptions, O as SinglePathOptions, S as MSTOptions, T as PathOptions, _ as GraphNode, n as AllPairsShortestPathsOptions, p as GraphEdge, t as AStarOptions, u as Graph, y as GraphPath } from "./types-BzckPChi.mjs";
+
+//#region src/algorithms/centrality.d.ts
+interface IterativeCentralityOptions {
+  alpha?: number;
+  maxIterations?: number;
+  tolerance?: number;
+}
+interface HITSResult {
+  hubs: Record<string, number>;
+  authorities: Record<string, number>;
+}
+/**
+ * Returns degree centrality scores for all nodes.
+ *
+ * Degree centrality is the node degree normalized by `n - 1`.
+ *
+ * @example
+ * ```ts
+ * const scores = getDegreeCentrality(graph);
+ * console.log(scores.a); // 0.5
+ * ```
+ */
+declare function getDegreeCentrality(graph: Graph): Record<string, number>;
+/**
+ * Returns in-degree centrality scores for all nodes.
+ *
+ * In-degree centrality is the incoming degree normalized by `n - 1`.
+ */
+declare function getInDegreeCentrality(graph: Graph): Record<string, number>;
+/**
+ * Returns out-degree centrality scores for all nodes.
+ *
+ * Out-degree centrality is the outgoing degree normalized by `n - 1`.
+ */
+declare function getOutDegreeCentrality(graph: Graph): Record<string, number>;
+/**
+ * Returns closeness centrality scores for all nodes.
+ *
+ * Distances are computed over unweighted shortest paths using the graph's
+ * existing directed or undirected edge semantics.
+ */
+declare function getClosenessCentrality(graph: Graph): Record<string, number>;
+/**
+ * Returns betweenness centrality scores for all nodes.
+ *
+ * Uses Brandes' algorithm over unweighted shortest paths and returns
+ * normalized scores.
+ */
+declare function getBetweennessCentrality(graph: Graph): Record<string, number>;
+/**
+ * Returns PageRank scores for all nodes.
+ *
+ * Uses power iteration with damping factor `alpha`.
+ */
+declare function getPageRank(graph: Graph, options?: IterativeCentralityOptions): Record<string, number>;
+/**
+ * Returns HITS hub and authority scores for all nodes.
+ *
+ * Uses power iteration and L2 normalization per iteration.
+ */
+declare function getHITS(graph: Graph, options?: IterativeCentralityOptions): HITSResult;
+/**
+ * Returns eigenvector centrality scores for all nodes.
+ *
+ * Uses power iteration over incoming neighbors for directed graphs and
+ * undirected adjacency for undirected graphs.
+ */
+declare function getEigenvectorCentrality(graph: Graph, options?: IterativeCentralityOptions): Record<string, number>;
+//#endregion
+//#region src/algorithms/community.d.ts
+interface GirvanNewmanOptions {
+  level?: number;
+  maxLevels?: number;
+}
+interface LabelPropagationOptions {
+  maxIterations?: number;
+}
+type Community<N = any> = GraphNode<N>[];
+/**
+ * Returns label-propagation communities for the graph.
+ *
+ * The implementation is deterministic: ties are broken by lexicographic label
+ * order so test results remain stable.
+ */
+declare function getLabelPropagationCommunities<N>(graph: Graph<N>, options?: LabelPropagationOptions): Community<N>[];
+/**
+ * Lazily yields Girvan-Newman community splits as edge betweenness removes
+ * bridge-like edges from the graph.
+ */
+declare function genGirvanNewmanCommunities<N>(graph: Graph<N>, options?: GirvanNewmanOptions): Generator<Community<N>[]>;
+/**
+ * Returns the requested Girvan-Newman split level eagerly.
+ *
+ * `level: 1` returns the first split yielded by `genGirvanNewmanCommunities`.
+ */
+declare function getGirvanNewmanCommunities<N>(graph: Graph<N>, options?: GirvanNewmanOptions): Community<N>[];
+/**
+ * Returns the modularity score for a partition of communities.
+ *
+ * Community algorithms in this module treat the graph as undirected.
+ */
+declare function getModularity<N>(graph: Graph<N>, communities: Community<N>[]): number;
+/**
+ * Returns communities found by greedily merging partitions that improve
+ * modularity the most at each step.
+ */
+declare function getGreedyModularityCommunities<N>(graph: Graph<N>): Community<N>[];
+//#endregion
+//#region src/algorithms/connectivity.d.ts
+/**
+ * Returns bridge edges whose removal disconnects the graph.
+ *
+ * Connectivity algorithms in this module treat the graph as undirected.
+ */
+declare function getBridges<N, E>(graph: Graph<N, E>): GraphEdge<E>[];
+/**
+ * Returns articulation points (cut vertices) for the graph.
+ *
+ * Connectivity algorithms in this module treat the graph as undirected.
+ */
+declare function getArticulationPoints<N, E>(graph: Graph<N, E>): GraphNode<N>[];
+/**
+ * Returns biconnected components as arrays of nodes.
+ *
+ * Articulation points may appear in multiple returned components.
+ */
+declare function getBiconnectedComponents<N, E>(graph: Graph<N, E>): GraphNode<N>[][];
+//#endregion
+//#region src/algorithms/isomorphism.d.ts
+interface IsomorphismOptions<N = any, E = any> {
+  nodeMatch?: (a: GraphNode<N>, b: GraphNode<N>) => boolean;
+  edgeMatch?: (a: GraphEdge<E>, b: GraphEdge<E>) => boolean;
+}
+/**
+ * Returns whether two graphs are structurally isomorphic.
+ *
+ * Optional `nodeMatch` and `edgeMatch` predicates can refine the match using
+ * node and edge payloads.
+ */
+declare function isIsomorphic<N, E>(graphA: Graph<N, E>, graphB: Graph<N, E>, options?: IsomorphismOptions<N, E>): boolean;
+//#endregion
+//#region src/algorithms.d.ts
+/**
+ * Breadth-first traversal generator yielding nodes level by level.
+ *
+ * **O(V + E)** time, **O(V)** space.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, bfs } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }, { id: 'bc', sourceId: 'b', targetId: 'c' }],
+ * });
+ *
+ * for (const node of bfs(graph, 'a')) {
+ *   console.log(node.id); // 'a', 'b', 'c'
+ * }
+ * ```
+ */
+declare function bfs<N>(graph: Graph<N>, startId: string): Generator<GraphNode<N>>;
+/**
+ * Depth-first traversal generator yielding nodes as visited.
+ *
+ * **O(V + E)** time, **O(V)** space.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, dfs } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }, { id: 'bc', sourceId: 'b', targetId: 'c' }],
+ * });
+ *
+ * for (const node of dfs(graph, 'a')) {
+ *   console.log(node.id); // 'a', 'b', 'c'
+ * }
+ * ```
+ */
+declare function dfs<N>(graph: Graph<N>, startId: string): Generator<GraphNode<N>>;
+/**
+ * Checks whether the graph contains no cycles.
+ *
+ * **O(V + E)** time.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, isAcyclic } from '@statelyai/graph';
+ *
+ * const dag = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * isAcyclic(dag); // true
+ * ```
+ */
+declare function isAcyclic(graph: Graph): boolean;
+/**
+ * Returns connected components as arrays of nodes.
+ * Treats all edges as undirected for connectivity.
+ *
+ * **O(V + E)** time.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getConnectedComponents } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * const components = getConnectedComponents(graph);
+ * // [[nodeA, nodeB], [nodeC]]
+ * ```
+ */
+declare function getConnectedComponents<N>(graph: Graph<N>): GraphNode<N>[][];
+/**
+ * Returns a topological ordering of nodes, or `null` if the graph is cyclic.
+ *
+ * **O(V + E)** time (Kahn's algorithm).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getTopologicalSort } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *   ],
+ * });
+ *
+ * const sorted = getTopologicalSort(graph);
+ * // [nodeA, nodeB, nodeC]
+ * ```
+ */
+declare function getTopologicalSort<N>(graph: Graph<N>): GraphNode<N>[] | null;
+/**
+ * Checks whether a path exists between two nodes.
+ *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, hasPath } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * hasPath(graph, 'a', 'b'); // true
+ * hasPath(graph, 'a', 'c'); // false
+ * ```
+ */
+declare function hasPath(graph: Graph, sourceId: string, targetId: string): boolean;
+/**
+ * Checks whether the graph is connected (all nodes reachable from any node).
+ *
+ * **O(V + E)** time.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, isConnected } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [{ id: 'ab', sourceId: 'a', targetId: 'b' }],
+ * });
+ *
+ * isConnected(graph); // true
+ * ```
+ */
+declare function isConnected(graph: Graph): boolean;
+/**
+ * Checks whether the graph is a tree (connected and acyclic).
+ *
+ * **O(V + E)** time.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, isTree } from '@statelyai/graph';
+ *
+ * const tree = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'ac', sourceId: 'a', targetId: 'c' },
+ *   ],
+ * });
+ *
+ * isTree(tree); // true
+ * ```
+ */
+declare function isTree(graph: Graph): boolean;
+/**
+ * Lazily yields all shortest paths from a source node.
+ * Use `getShortestPaths` for the full array.
+ *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted),
+ * plus **O(P)** per path yielded where P is the path length.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, genShortestPaths } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * for (const path of genShortestPaths(graph)) {
+ *   console.log(path.steps.map(s => s.node.id));
+ * }
+ * ```
+ */
+declare function genShortestPaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>): Generator<GraphPath<N, E>>;
+/**
+ * Returns all shortest paths from a source node as an array.
+ * Delegates to `genShortestPaths` internally.
+ *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getShortestPaths } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * const paths = getShortestPaths(graph);
+ * // paths to 'b' and 'c' from 'a'
+ * ```
+ */
+declare function getShortestPaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>): GraphPath<N, E>[];
+/**
+ * Returns a single shortest path from source to target, or `undefined` if unreachable.
+ *
+ * **O(V + E)** time (BFS) or **O((V + E) log V)** (Dijkstra when weighted).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getShortestPath } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * const path = getShortestPath(graph, { to: 'c' });
+ * // path.steps -> [{node: nodeB, edge: ...}, {node: nodeC, edge: ...}]
+ * ```
+ */
+declare function getShortestPath<N, E>(graph: Graph<N, E>, opts: SinglePathOptions<E>): GraphPath<N, E> | undefined;
+/**
+ * Returns all simple (acyclic) paths from a source node as an array.
+ * Delegates to `genSimplePaths` internally.
+ *
+ * **O(V!)** worst-case (exponential in dense graphs).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getSimplePaths } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *     { id: 'ac', sourceId: 'a', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * const paths = getSimplePaths(graph, { to: 'c' });
+ * // two paths: a->b->c and a->c
+ * ```
+ */
+declare function getSimplePaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>): GraphPath<N, E>[];
+/**
+ * Lazily yields all simple (acyclic) paths from a source node via DFS backtracking.
+ * Use `getSimplePaths` for the full array.
+ *
+ * **O(V!)** worst-case (exponential in dense graphs).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, genSimplePaths } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *     { id: 'ac', sourceId: 'a', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * for (const path of genSimplePaths(graph, { to: 'c' })) {
+ *   console.log(path.steps.map(s => s.node.id));
+ *   // ['b', 'c'] or ['c']
+ * }
+ * ```
+ */
+declare function genSimplePaths<N, E>(graph: Graph<N, E>, opts?: PathOptions<E>): Generator<GraphPath<N, E>>;
+/**
+ * Returns a single simple (acyclic) path from source to target, or `undefined` if unreachable.
+ *
+ * **O(V + E)** typical, **O(V!)** worst-case.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getSimplePath } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * const path = getSimplePath(graph, { to: 'c' });
+ * // path.steps -> [{node: nodeB, edge: ...}, {node: nodeC, edge: ...}]
+ * ```
+ */
+declare function getSimplePath<N, E>(graph: Graph<N, E>, opts: SinglePathOptions<E>): GraphPath<N, E> | undefined;
+/**
+ * Returns strongly connected components using Tarjan's algorithm.
+ * Only meaningful for directed graphs.
+ *
+ * **O(V + E)** time.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getStronglyConnectedComponents } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'ba', sourceId: 'b', targetId: 'a' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *   ],
+ * });
+ *
+ * const sccs = getStronglyConnectedComponents(graph);
+ * // [[nodeA, nodeB], [nodeC]]
+ * ```
+ */
+declare function getStronglyConnectedComponents<N>(graph: Graph<N>): GraphNode<N>[][];
+/**
+ * Returns all elementary cycles as an array of paths.
+ * Delegates to `genCycles` internally.
+ *
+ * **O((V + E) · C)** where C is the number of elementary cycles (can be exponential).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getCycles } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'ba', sourceId: 'b', targetId: 'a' },
+ *   ],
+ * });
+ *
+ * const cycles = getCycles(graph);
+ * // one cycle: a -> b -> a
+ * ```
+ */
+declare function getCycles<N, E>(graph: Graph<N, E>): GraphPath<N, E>[];
+/**
+ * Lazily yields elementary cycles one at a time.
+ * Use `getCycles` for the full array.
+ *
+ * **O((V + E) · C)** where C is the number of elementary cycles (can be exponential).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, genCycles } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'ba', sourceId: 'b', targetId: 'a' },
+ *   ],
+ * });
+ *
+ * for (const cycle of genCycles(graph)) {
+ *   console.log(cycle.steps.map(s => s.node.id)); // ['b', 'a']
+ * }
+ * ```
+ */
+declare function genCycles<N, E>(graph: Graph<N, E>): Generator<GraphPath<N, E>>;
+/**
+ * Returns a single canonical preorder (DFS visit-order) sequence.
+ * Visits neighbors in the order they appear in the adjacency list.
+ *
+ * **O(V + E)** time.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getPreorder } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * const order = getPreorder(graph);
+ * // [nodeA, nodeB, nodeC]
+ * ```
+ */
+declare function getPreorder<N>(graph: Graph<N>, opts?: TraversalOptions): GraphNode<N>[];
+/**
+ * Returns a single canonical postorder (DFS finish-order) sequence.
+ * Visits neighbors in the order they appear in the adjacency list.
+ *
+ * **O(V + E)** time.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getPostorder } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * const order = getPostorder(graph);
+ * // [nodeC, nodeB, nodeA]
+ * ```
+ */
+declare function getPostorder<N>(graph: Graph<N>, opts?: TraversalOptions): GraphNode<N>[];
+/**
+ * Returns all possible preorder sequences as an array. Can be exponential -- prefer `genPreorders`.
+ *
+ * **O(V! · V)** worst-case (exponential).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getPreorders } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'ac', sourceId: 'a', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * const allOrders = getPreorders(graph);
+ * // [[nodeA, nodeB, nodeC], [nodeA, nodeC, nodeB]]
+ * ```
+ */
+declare function getPreorders<N>(graph: Graph<N>, opts?: TraversalOptions): GraphNode<N>[][];
+/**
+ * Returns all possible postorder sequences as an array. Can be exponential -- prefer `genPostorders`.
+ *
+ * **O(V! · V)** worst-case (exponential).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getPostorders } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'ac', sourceId: 'a', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * const allOrders = getPostorders(graph);
+ * // [[nodeB, nodeC, nodeA], [nodeC, nodeB, nodeA]]
+ * ```
+ */
+declare function getPostorders<N>(graph: Graph<N>, opts?: TraversalOptions): GraphNode<N>[][];
+/**
+ * Lazily yields all possible preorder (DFS visit-order) sequences.
+ * Different neighbor exploration orders yield different sequences.
+ * Use `getPreorder()` for a single canonical ordering.
+ *
+ * **O(V! · V)** worst-case (exponential).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, genPreorders } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'ac', sourceId: 'a', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * for (const order of genPreorders(graph)) {
+ *   console.log(order.map(n => n.id));
+ *   // ['a', 'b', 'c'] or ['a', 'c', 'b']
+ * }
+ * ```
+ */
+declare function genPreorders<N>(graph: Graph<N>, opts?: TraversalOptions): Generator<GraphNode<N>[]>;
+/**
+ * Lazily yields all possible postorder (DFS finish-order) sequences.
+ * Different neighbor exploration orders yield different sequences.
+ * Use `getPostorder()` for a single canonical ordering.
+ *
+ * **O(V! · V)** worst-case (exponential).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, genPostorders } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'ac', sourceId: 'a', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * for (const order of genPostorders(graph)) {
+ *   console.log(order.map(n => n.id));
+ *   // ['b', 'c', 'a'] or ['c', 'b', 'a']
+ * }
+ * ```
+ */
+declare function genPostorders<N>(graph: Graph<N>, opts?: TraversalOptions): Generator<GraphNode<N>[]>;
+/**
+ * Returns a minimum spanning tree of the graph.
+ * Only meaningful for connected undirected graphs (or the component reachable
+ * from an arbitrary start node in directed graphs).
+ *
+ * **O(E log E)** using either edge sorting (Kruskal) or a min-heap (Prim).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getMinimumSpanningTree } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   type: 'undirected',
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b', data: { weight: 1 } },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c', data: { weight: 2 } },
+ *     { id: 'ac', sourceId: 'a', targetId: 'c', data: { weight: 3 } },
+ *   ],
+ * });
+ *
+ * const mst = getMinimumSpanningTree(graph, {
+ *   getWeight: (e) => e.data.weight,
+ * });
+ * // mst has edges 'ab' and 'bc' (total weight 3)
+ * ```
+ */
+declare function getMinimumSpanningTree<N, E>(graph: Graph<N, E>, opts?: MSTOptions<E>): Graph<N, E>;
+/**
+ * Returns shortest paths between all pairs of nodes.
+ * Algorithm 'dijkstra' (default): runs getShortestPaths per source node.
+ * Algorithm 'floyd-warshall': classic dynamic programming.
+ *
+ * **O(V · (V + E) log V)** (Dijkstra) or **O(V³)** (Floyd-Warshall).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getAllPairsShortestPaths } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *   ],
+ * });
+ *
+ * const allPaths = getAllPairsShortestPaths(graph);
+ * // paths for every reachable (source, target) pair
+ * ```
+ */
+declare function getAllPairsShortestPaths<N, E>(graph: Graph<N, E>, opts?: AllPairsShortestPathsOptions<E>): GraphPath<N, E>[];
+/**
+ * Returns a shortest path using A* search with an admissible heuristic.
+ * More efficient than Dijkstra when a good heuristic is available.
+ *
+ * **O((V + E) log V)** time with a good heuristic; degrades to Dijkstra
+ * with `heuristic: () => 0`.
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getAStarPath } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [
+ *     { id: 'a', x: 0, y: 0 },
+ *     { id: 'b', x: 1, y: 0 },
+ *     { id: 'c', x: 1, y: 1 },
+ *   ],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b', weight: 1 },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c', weight: 1 },
+ *     { id: 'ac', sourceId: 'a', targetId: 'c', weight: 3 },
+ *   ],
+ * });
+ *
+ * const path = getAStarPath(graph, {
+ *   from: 'a',
+ *   to: 'c',
+ *   heuristic: (nodeId) => {
+ *     const node = graph.nodes.find(n => n.id === nodeId)!;
+ *     const target = graph.nodes.find(n => n.id === 'c')!;
+ *     return Math.abs(node.x! - target.x!) + Math.abs(node.y! - target.y!);
+ *   },
+ * });
+ * // path: a -> b -> c (weight 2, cheaper than direct a -> c)
+ * ```
+ */
+declare function getAStarPath<N, E>(graph: Graph<N, E>, opts: AStarOptions<E>): GraphPath<N, E> | undefined;
+/**
+ * Joins two paths end-to-end. The last node of the head path must equal
+ * the source of the tail path (the overlap node).
+ *
+ * Steps are concatenated: head.steps ++ tail.steps (tail already starts
+ * from the overlap node, so no slicing is needed).
+ *
+ * @example
+ * ```ts
+ * import { createGraph, getShortestPath, joinPaths } from '@statelyai/graph';
+ *
+ * const graph = createGraph({
+ *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+ *   edges: [
+ *     { id: 'ab', sourceId: 'a', targetId: 'b' },
+ *     { id: 'bc', sourceId: 'b', targetId: 'c' },
+ *   ],
+ *   initialNodeId: 'a',
+ * });
+ *
+ * const ab = getShortestPath(graph, { to: 'b' })!;
+ * const bc = getShortestPath(graph, { from: 'b', to: 'c' })!;
+ * const ac = joinPaths(ab, bc);
+ * // ac: a -> b -> c
+ * ```
+ */
+declare function joinPaths<N, E>(headPath: GraphPath<N, E>, tailPath: GraphPath<N, E>): GraphPath<N, E>;
+//#endregion
+export { getArticulationPoints as A, HITSResult as B, hasPath as C, joinPaths as D, isTree as E, genGirvanNewmanCommunities as F, getEigenvectorCentrality as G, getBetweennessCentrality as H, getGirvanNewmanCommunities as I, getOutDegreeCentrality as J, getHITS as K, getGreedyModularityCommunities as L, getBridges as M, GirvanNewmanOptions as N, IsomorphismOptions as O, LabelPropagationOptions as P, getLabelPropagationCommunities as R, getTopologicalSort as S, isConnected as T, getClosenessCentrality as U, IterativeCentralityOptions as V, getDegreeCentrality as W, getPageRank as Y, getShortestPath as _, genPreorders as a, getSimplePaths as b, getAStarPath as c, getCycles as d, getMinimumSpanningTree as f, getPreorders as g, getPreorder as h, genPostorders as i, getBiconnectedComponents as j, isIsomorphic as k, getAllPairsShortestPaths as l, getPostorders as m, dfs as n, genShortestPaths as o, getPostorder as p, getInDegreeCentrality as q, genCycles as r, genSimplePaths as s, bfs as t, getConnectedComponents as u, getShortestPaths as v, isAcyclic as w, getStronglyConnectedComponents as x, getSimplePath as y, getModularity as z };