@statelyai/graph 0.13.0 → 1.0.0

package/dist/queries.d.mts

@@ -1,515 +1,2 @@
-import { g as GraphNode, p as GraphEdge, u as Graph, y as GraphPort } from "./types-CnZ01raw.mjs";
-
-//#region src/queries.d.ts
-
-/**
- * Returns all edges (incoming + outgoing) connected to a node.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
- *   edges: [
- *     { id: 'e1', sourceId: 'a', targetId: 'b' },
- *     { id: 'e2', sourceId: 'c', targetId: 'b' },
- *   ],
- * });
- * getEdgesOf(graph, 'b');
- * // => [edge e1, edge e2]
- * ```
- */
-declare function getEdgesOf<N, E>(graph: Graph<N, E>, nodeId: string): GraphEdge<E>[];
-/**
- * Returns incoming edges to a node.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }],
- *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
- * });
- * getInEdges(graph, 'b');
- * // => [edge e1]
- * getInEdges(graph, 'a');
- * // => []
- * ```
- */
-declare function getInEdges<N, E>(graph: Graph<N, E>, nodeId: string): GraphEdge<E>[];
-/**
- * Returns outgoing edges from a node.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }],
- *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
- * });
- * getOutEdges(graph, 'a');
- * // => [edge e1]
- * getOutEdges(graph, 'b');
- * // => []
- * ```
- */
-declare function getOutEdges<N, E>(graph: Graph<N, E>, nodeId: string): GraphEdge<E>[];
-/**
- * Returns all edges from `sourceId` to `targetId`.
- * For undirected graphs, checks both directions.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }],
- *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
- * });
- * getEdgesBetween(graph, 'a', 'b');
- * // => [edge e1]
- * getEdgesBetween(graph, 'b', 'a');
- * // => [] (directed graph)
- * ```
- */
-declare function getEdgesBetween<N, E>(graph: Graph<N, E>, sourceId: string, targetId: string): GraphEdge<E>[];
-/**
- * Returns direct successor nodes (targets of outgoing edges).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
- *   edges: [
- *     { id: 'e1', sourceId: 'a', targetId: 'b' },
- *     { id: 'e2', sourceId: 'a', targetId: 'c' },
- *   ],
- * });
- * getSuccessors(graph, 'a');
- * // => [node b, node c]
- * ```
- */
-declare function getSuccessors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
-/**
- * Returns direct predecessor nodes (sources of incoming edges).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
- *   edges: [
- *     { id: 'e1', sourceId: 'a', targetId: 'c' },
- *     { id: 'e2', sourceId: 'b', targetId: 'c' },
- *   ],
- * });
- * getPredecessors(graph, 'c');
- * // => [node a, node b]
- * ```
- */
-declare function getPredecessors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
-/**
- * Returns all neighbor nodes (successors + predecessors).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
- *   edges: [
- *     { id: 'e1', sourceId: 'a', targetId: 'b' },
- *     { id: 'e2', sourceId: 'c', targetId: 'b' },
- *   ],
- * });
- * getNeighbors(graph, 'b');
- * // => [node a, node c]
- * ```
- */
-declare function getNeighbors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
-/**
- * Returns the total degree of a node (inDegree + outDegree).
- * For undirected graphs, each edge is counted once.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
- *   edges: [
- *     { id: 'e1', sourceId: 'a', targetId: 'b' },
- *     { id: 'e2', sourceId: 'c', targetId: 'b' },
- *   ],
- * });
- * getDegree(graph, 'b'); // => 2
- * getDegree(graph, 'a'); // => 1
- * ```
- */
-declare function getDegree(graph: Graph, nodeId: string): number;
-/**
- * Returns the in-degree of a node (number of incoming edges).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }],
- *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
- * });
- * getInDegree(graph, 'b'); // => 1
- * getInDegree(graph, 'a'); // => 0
- * ```
- */
-declare function getInDegree(graph: Graph, nodeId: string): number;
-/**
- * Returns the out-degree of a node (number of outgoing edges).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }],
- *   edges: [{ id: 'e1', sourceId: 'a', targetId: 'b' }],
- * });
- * getOutDegree(graph, 'a'); // => 1
- * getOutDegree(graph, 'b'); // => 0
- * ```
- */
-declare function getOutDegree(graph: Graph, nodeId: string): number;
-/**
- * Returns direct children of a node in the hierarchy.
- * Pass `null` to get root-level nodes.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'parent' },
- *     { id: 'child1', parentId: 'parent' },
- *     { id: 'child2', parentId: 'parent' },
- *   ],
- * });
- * getChildren(graph, 'parent');
- * // => [node child1, node child2]
- * getChildren(graph, null);
- * // => [node parent]
- * ```
- */
-declare function getChildren<N>(graph: Graph<N>, nodeId: string | null): GraphNode<N>[];
-/**
- * Returns the parent node in the hierarchy, or `undefined` if root-level.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'parent' },
- *     { id: 'child', parentId: 'parent' },
- *   ],
- * });
- * getParent(graph, 'child');
- * // => node parent
- * getParent(graph, 'parent');
- * // => undefined
- * ```
- */
-declare function getParent<N>(graph: Graph<N>, nodeId: string): GraphNode<N> | undefined;
-/**
- * Returns all ancestors from the node up to the root (nearest parent first).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'root' },
- *     { id: 'mid', parentId: 'root' },
- *     { id: 'leaf', parentId: 'mid' },
- *   ],
- * });
- * getAncestors(graph, 'leaf');
- * // => [node mid, node root]
- * ```
- */
-declare function getAncestors<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
-/**
- * Returns all descendants recursively (depth-first).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'root' },
- *     { id: 'child', parentId: 'root' },
- *     { id: 'grandchild', parentId: 'child' },
- *   ],
- * });
- * getDescendants(graph, 'root');
- * // => [node child, node grandchild]
- * ```
- */
-declare function getDescendants<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
-/**
- * Returns all root nodes (nodes with no parent).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'root1' },
- *     { id: 'root2' },
- *     { id: 'child', parentId: 'root1' },
- *   ],
- * });
- * getRoots(graph);
- * // => [node root1, node root2]
- * ```
- */
-declare function getRoots<N>(graph: Graph<N>): GraphNode<N>[];
-/**
- * Whether a node has children (is a compound/group node).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'parent' },
- *     { id: 'child', parentId: 'parent' },
- *   ],
- * });
- * isCompound(graph, 'parent'); // => true
- * isCompound(graph, 'child');  // => false
- * ```
- */
-declare function isCompound(graph: Graph, nodeId: string): boolean;
-/**
- * Whether a node has no children (is a leaf/atomic node).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'parent' },
- *     { id: 'child', parentId: 'parent' },
- *   ],
- * });
- * isLeaf(graph, 'child');  // => true
- * isLeaf(graph, 'parent'); // => false
- * ```
- */
-declare function isLeaf(graph: Graph, nodeId: string): boolean;
-/**
- * Depth of a node in the hierarchy (root = 0).
- * Returns -1 if the node is not found.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'root' },
- *     { id: 'child', parentId: 'root' },
- *     { id: 'grandchild', parentId: 'child' },
- *   ],
- * });
- * getDepth(graph, 'root');       // => 0
- * getDepth(graph, 'child');      // => 1
- * getDepth(graph, 'grandchild'); // => 2
- * ```
- */
-declare function getDepth(graph: Graph, nodeId: string): number;
-/**
- * Sibling nodes (same parentId, excluding the node itself).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'parent' },
- *     { id: 'a', parentId: 'parent' },
- *     { id: 'b', parentId: 'parent' },
- *     { id: 'c', parentId: 'parent' },
- *   ],
- * });
- * getSiblings(graph, 'a');
- * // => [node b, node c]
- * ```
- */
-declare function getSiblings<N>(graph: Graph<N>, nodeId: string): GraphNode<N>[];
-/**
- * Least Common Ancestor -- deepest proper ancestor of all given nodes.
- * A proper ancestor excludes the input nodes themselves.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'root' },
- *     { id: 'a', parentId: 'root' },
- *     { id: 'b', parentId: 'root' },
- *     { id: 'a1', parentId: 'a' },
- *   ],
- * });
- * getLCA(graph, 'a1', 'b');
- * // => node root
- * getLCA(graph, 'a', 'b');
- * // => node root
- * ```
- */
-declare function getLCA<N>(graph: Graph<N>, ...nodeIds: string[]): GraphNode<N> | undefined;
-/**
- * Returns a map of nodeId → shortest-path distance for all sibling nodes
- * (same parentId). Distance is measured from the parent's `initialNodeId`
- * (or `graph.initialNodeId` for root-level nodes).
- *
- * Only follows edges between siblings. Unreachable siblings are omitted.
- *
- * @example Root-level nodes (uses `graph.initialNodeId`):
- * ```ts
- * const graph = createGraph({
- *   initialNodeId: 'a',
- *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
- *   edges: [
- *     { id: 'e1', sourceId: 'a', targetId: 'b' },
- *     { id: 'e2', sourceId: 'b', targetId: 'c' },
- *   ],
- * });
- * getRelativeDistanceMap(graph, null);
- * // => { a: 0, b: 1, c: 2 }
- * ```
- *
- * @example Nested nodes (uses parent's `initialNodeId`):
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'parent', initialNodeId: 's1' },
- *     { id: 's1', parentId: 'parent' },
- *     { id: 's2', parentId: 'parent' },
- *     { id: 's3', parentId: 'parent' },
- *   ],
- *   edges: [
- *     { id: 'e1', sourceId: 's1', targetId: 's2' },
- *     { id: 'e2', sourceId: 's2', targetId: 's3' },
- *   ],
- * });
- * getRelativeDistanceMap(graph, 'parent');
- * // => { s1: 0, s2: 1, s3: 2 }
- * ```
- */
-declare function getRelativeDistanceMap(graph: Graph, parentId: string | null): Record<string, number>;
-/**
- * Returns the shortest-path distance of a node from its parent's initial node.
- * Automatically scopes to the node's sibling group (same `parentId`).
- *
- * Returns `undefined` if the node is not found or unreachable.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   initialNodeId: 'a',
- *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
- *   edges: [
- *     { id: 'e1', sourceId: 'a', targetId: 'b' },
- *     { id: 'e2', sourceId: 'b', targetId: 'c' },
- *   ],
- * });
- * getRelativeDistance(graph, 'a'); // => 0
- * getRelativeDistance(graph, 'b'); // => 1
- * getRelativeDistance(graph, 'c'); // => 2
- * ```
- *
- * @example Nested nodes:
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'parent', initialNodeId: 's1' },
- *     { id: 's1', parentId: 'parent' },
- *     { id: 's2', parentId: 'parent' },
- *   ],
- *   edges: [{ id: 'e1', sourceId: 's1', targetId: 's2' }],
- * });
- * getRelativeDistance(graph, 's1'); // => 0
- * getRelativeDistance(graph, 's2'); // => 1
- * ```
- */
-declare function getRelativeDistance(graph: Graph, nodeId: string): number | undefined;
-/**
- * Nodes with no incoming edges (inDegree 0).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
- *   edges: [
- *     { id: 'e1', sourceId: 'a', targetId: 'b' },
- *     { id: 'e2', sourceId: 'b', targetId: 'c' },
- *   ],
- * });
- * getSources(graph);
- * // => [node a]
- * ```
- */
-declare function getSources<N>(graph: Graph<N>): GraphNode<N>[];
-/**
- * Nodes with no outgoing edges (outDegree 0).
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
- *   edges: [
- *     { id: 'e1', sourceId: 'a', targetId: 'b' },
- *     { id: 'e2', sourceId: 'b', targetId: 'c' },
- *   ],
- * });
- * getSinks(graph);
- * // => [node c]
- * ```
- */
-declare function getSinks<N>(graph: Graph<N>): GraphNode<N>[];
-/**
- * Get a port by name on a node, or `undefined` if not found.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{
- *     id: 'a',
- *     ports: [{ name: 'out', direction: 'out' }],
- *   }],
- * });
- * getPort(graph, 'a', 'out'); // => { name: 'out', direction: 'out', ... }
- * getPort(graph, 'a', 'missing'); // => undefined
- * ```
- */
-declare function getPort<N, E, G, P>(graph: Graph<N, E, G, P>, nodeId: string, portName: string): GraphPort<P> | undefined;
-/**
- * Get all ports on a node. Returns `[]` if the node has no ports or doesn't exist.
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [{
- *     id: 'a',
- *     ports: [
- *       { name: 'in', direction: 'in' },
- *       { name: 'out', direction: 'out' },
- *     ],
- *   }],
- * });
- * getPorts(graph, 'a'); // => [port in, port out]
- * ```
- */
-declare function getPorts<N, E, G, P>(graph: Graph<N, E, G, P>, nodeId: string): GraphPort<P>[];
-/**
- * Get all edges connected to a specific port on a node.
- *
- * Returns edges where:
- * - `sourceId === nodeId && sourcePort === portName`, or
- * - `targetId === nodeId && targetPort === portName`
- *
- * @example
- * ```ts
- * const graph = createGraph({
- *   nodes: [
- *     { id: 'a', ports: [{ name: 'out', direction: 'out' }] },
- *     { id: 'b', ports: [{ name: 'in', direction: 'in' }] },
- *   ],
- *   edges: [{
- *     id: 'e1', sourceId: 'a', targetId: 'b',
- *     sourcePort: 'out', targetPort: 'in',
- *   }],
- * });
- * getEdgesByPort(graph, 'a', 'out'); // => [edge e1]
- * ```
- */
-declare function getEdgesByPort<N, E>(graph: Graph<N, E>, nodeId: string, portName: string): GraphEdge<E>[];
-//#endregion
+import { C as getSinks, D as isLeaf, E as isCompound, S as getSiblings, T as getSuccessors, _ as getPorts, a as getDescendants, b as getRelativeDistanceMap, c as getEdgesOf, d as getLCA, f as getNeighbors, g as getPort, h as getParent, i as getDepth, l as getInDegree, m as getOutEdges, n as getChildren, o as getEdgesBetween, p as getOutDegree, r as getDegree, s as getEdgesByPort, t as getAncestors, u as getInEdges, v as getPredecessors, w as getSources, x as getRoots, y as getRelativeDistance } from "./queries-BlkA1HAN.mjs";
 export { getAncestors, getChildren, getDegree, getDepth, getDescendants, getEdgesBetween, getEdgesByPort, getEdgesOf, getInDegree, getInEdges, getLCA, getNeighbors, getOutDegree, getOutEdges, getParent, getPort, getPorts, getPredecessors, getRelativeDistance, getRelativeDistanceMap, getRoots, getSiblings, getSinks, getSources, getSuccessors, isCompound, isLeaf };

package/dist/queries.mjs

@@ -1,4 +1,5 @@
-import { t as getIndex } from "./indexing-DUl3kTqm.mjs";
+import { t as getIndex } from "./indexing-DR8M1vBy.mjs";
+import { t as getEdgeMode } from "./mode-D8OnHFBk.mjs";
 
 //#region src/queries.ts
 /**
@@ -74,7 +75,7 @@ function getOutEdges(graph, nodeId) {
 }
 /**
 * Returns all edges from `sourceId` to `targetId`.
-* For undirected graphs, checks both directions.
+* Edges whose effective mode is not `'directed'` are matched both ways.
 *
 * @example
 * ```ts
@@ -85,7 +86,7 @@ function getOutEdges(graph, nodeId) {
 * getEdgesBetween(graph, 'a', 'b');
 * // => [edge e1]
 * getEdgesBetween(graph, 'b', 'a');
-* // => [] (directed graph)
+* // => [] (directed edge)
 * ```
 */
 function getEdgesBetween(graph, sourceId, targetId) {
@@ -101,14 +102,12 @@ function getEdgesBetween(graph, sourceId, targetId) {
 			result.push(e);
 		}
 	}
-	if (graph.type === "undirected") {
-		const outIds2 = idx.outEdges.get(targetId) ?? [];
-		for (const eid of outIds2) {
-			if (seen.has(eid)) continue;
-			const ai = idx.edgeById.get(eid);
-			const e = graph.edges[ai];
-			if (e.targetId === sourceId) result.push(e);
-		}
+	const outIds2 = idx.outEdges.get(targetId) ?? [];
+	for (const eid of outIds2) {
+		if (seen.has(eid)) continue;
+		const ai = idx.edgeById.get(eid);
+		const e = graph.edges[ai];
+		if (e.targetId === sourceId && getEdgeMode(graph, e) !== "directed") result.push(e);
 	}
 	return result;
 }
@@ -199,7 +198,8 @@ function getNeighbors(graph, nodeId) {
 }
 /**
 * Returns the total degree of a node (inDegree + outDegree).
-* For undirected graphs, each edge is counted once.
+* For graphs whose default mode is not `'directed'`, each incident edge is
+* counted once.
 *
 * @example
 * ```ts
@@ -216,7 +216,7 @@ function getNeighbors(graph, nodeId) {
 */
 function getDegree(graph, nodeId) {
 	const idx = getIndex(graph);
-	if (graph.type === "undirected") {
+	if (graph.mode !== "directed") {
 		const out = idx.outEdges.get(nodeId) ?? [];
 		const inE = idx.inEdges.get(nodeId) ?? [];
 		return new Set([...out, ...inE]).size;
@@ -591,10 +591,12 @@ function getRelativeDistanceMap(graph, parentId) {
 				queue.push(neighborId);
 			}
 		}
-		if (graph.type === "undirected") for (const eid of idx.inEdges.get(id) ?? []) {
+		for (const eid of idx.inEdges.get(id) ?? []) {
 			const ai = idx.edgeById.get(eid);
 			if (ai === void 0) continue;
-			const neighborId = graph.edges[ai].sourceId;
+			const edge = graph.edges[ai];
+			if (getEdgeMode(graph, edge) === "directed") continue;
+			const neighborId = edge.sourceId;
 			if (siblingSet.has(neighborId) && !dist.has(neighborId)) {
 				dist.set(neighborId, d + 1);
 				queue.push(neighborId);

package/dist/schemas.d.mts

@@ -1,4 +1,4 @@
-import { g as GraphNode, p as GraphEdge, u as Graph, y as GraphPort } from "./types-CnZ01raw.mjs";
+import { _ as GraphNode, b as GraphPort, p as GraphEdge, u as Graph } from "./types-3-FS9NV2.mjs";
 import * as z from "zod";
 
 //#region src/schemas.d.ts
@@ -15,7 +15,7 @@ declare const PortSchema: z.ZodObject<{
   y: z.ZodOptional<z.ZodNumber>;
   width: z.ZodOptional<z.ZodNumber>;
   height: z.ZodOptional<z.ZodNumber>;
-  style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
 }, z.core.$strip>;
 declare const NodeSchema: z.ZodObject<{
   type: z.ZodLiteral<"node">;
@@ -30,7 +30,7 @@ declare const NodeSchema: z.ZodObject<{
   height: z.ZodOptional<z.ZodNumber>;
   shape: z.ZodOptional<z.ZodString>;
   color: z.ZodOptional<z.ZodString>;
-  style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
   ports: z.ZodOptional<z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     direction: z.ZodEnum<{
@@ -44,7 +44,7 @@ declare const NodeSchema: z.ZodObject<{
     y: z.ZodOptional<z.ZodNumber>;
     width: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
-    style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
   }, z.core.$strip>>>;
 }, z.core.$strip>;
 declare const EdgeSchema: z.ZodObject<{
@@ -56,19 +56,25 @@ declare const EdgeSchema: z.ZodObject<{
   weight: z.ZodOptional<z.ZodNumber>;
   sourcePort: z.ZodOptional<z.ZodString>;
   targetPort: z.ZodOptional<z.ZodString>;
+  mode: z.ZodOptional<z.ZodEnum<{
+    directed: "directed";
+    undirected: "undirected";
+    bidirectional: "bidirectional";
+  }>>;
   data: z.ZodAny;
   x: z.ZodOptional<z.ZodNumber>;
   y: z.ZodOptional<z.ZodNumber>;
   width: z.ZodOptional<z.ZodNumber>;
   height: z.ZodOptional<z.ZodNumber>;
   color: z.ZodOptional<z.ZodString>;
-  style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
 }, z.core.$strip>;
 declare const GraphSchema: z.ZodObject<{
   id: z.ZodString;
-  type: z.ZodEnum<{
+  mode: z.ZodEnum<{
     directed: "directed";
     undirected: "undirected";
+    bidirectional: "bidirectional";
   }>;
   initialNodeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
   nodes: z.ZodArray<z.ZodObject<{
@@ -84,7 +90,7 @@ declare const GraphSchema: z.ZodObject<{
     height: z.ZodOptional<z.ZodNumber>;
     shape: z.ZodOptional<z.ZodString>;
     color: z.ZodOptional<z.ZodString>;
-    style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
     ports: z.ZodOptional<z.ZodArray<z.ZodObject<{
       name: z.ZodString;
       direction: z.ZodEnum<{
@@ -98,7 +104,7 @@ declare const GraphSchema: z.ZodObject<{
       y: z.ZodOptional<z.ZodNumber>;
       width: z.ZodOptional<z.ZodNumber>;
       height: z.ZodOptional<z.ZodNumber>;
-      style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+      style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
     }, z.core.$strip>>>;
   }, z.core.$strip>>;
   edges: z.ZodArray<z.ZodObject<{
@@ -110,13 +116,18 @@ declare const GraphSchema: z.ZodObject<{
     weight: z.ZodOptional<z.ZodNumber>;
     sourcePort: z.ZodOptional<z.ZodString>;
     targetPort: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+      directed: "directed";
+      undirected: "undirected";
+      bidirectional: "bidirectional";
+    }>>;
     data: z.ZodAny;
     x: z.ZodOptional<z.ZodNumber>;
     y: z.ZodOptional<z.ZodNumber>;
     width: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
     color: z.ZodOptional<z.ZodString>;
-    style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
   }, z.core.$strip>>;
   data: z.ZodAny;
   direction: z.ZodOptional<z.ZodEnum<{
@@ -125,7 +136,7 @@ declare const GraphSchema: z.ZodObject<{
     left: "left";
     right: "right";
   }>>;
-  style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+  style: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
 }, z.core.$strip>;
 interface GraphValidationIssue {
   code: string;