@statelyai/layout 0.0.0 → 0.0.1

package/dist/index-D2RodsZY.d.mts

@@ -0,0 +1,1210 @@
+import { LayoutConstraints } from "@statelyai/graph/layout";
+import { EntityRect, Graph, GraphEdge, GraphNode, GraphPatch, GraphPort, Point, VisualGraph } from "@statelyai/graph";
+
+//#region src/types.d.ts
+type AnyGraph = Graph<unknown, unknown, unknown, unknown>;
+type LayoutDirection = "up" | "down" | "left" | "right";
+type LayoutScope = {
+  mode: "full";
+} | {
+  mode: "incremental";
+  previous: VisualGraph;
+} | {
+  mode: "partial";
+  previous: VisualGraph;
+  nodeIds: readonly string[];
+} | {
+  mode: "route-only";
+  previous: VisualGraph;
+  edgeIds?: readonly string[];
+};
+interface LayoutDiagnostic {
+  severity: "info" | "warning" | "error";
+  code: string;
+  message: string;
+  entityIds?: readonly string[];
+  phase?: string;
+}
+interface LayoutPhaseMetrics {
+  id: string;
+  durationMs: number;
+}
+interface LayoutMetrics {
+  durationMs: number;
+  nodeCount: number;
+  edgeCount: number;
+  phases: readonly LayoutPhaseMetrics[];
+}
+interface LayoutCapabilities {
+  full: boolean;
+  incremental: boolean;
+  partial: boolean;
+  routeOnly: boolean;
+  hierarchy: boolean;
+  ports: boolean;
+}
+interface LayoutAlgorithm<Options = unknown> {
+  readonly id: string;
+  readonly capabilities: LayoutCapabilities;
+  layout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options: Options, context: LayoutExecutionContext): VisualGraph<N, E, G, P> | Promise<VisualGraph<N, E, G, P>>;
+}
+interface LayoutExecutionContext {
+  readonly scope: LayoutScope;
+  readonly signal?: AbortSignal;
+  readonly diagnostics: LayoutDiagnostic[];
+  measurePhase<T>(id: string, run: () => T): T;
+  throwIfAborted(): void;
+}
+interface LayoutRequest<N = unknown, E = unknown, G = unknown, P = unknown, O = unknown> {
+  graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>;
+  algorithm?: string | LayoutAlgorithm<O>;
+  options?: O;
+  scope?: LayoutScope;
+  signal?: AbortSignal;
+}
+interface LayoutResult<N = unknown, E = unknown, G = unknown, P = unknown> {
+  graph: VisualGraph<N, E, G, P>;
+  patches: readonly GraphPatch<N, E>[];
+  diagnostics: readonly LayoutDiagnostic[];
+  metrics: LayoutMetrics;
+}
+//#endregion
+//#region src/layered/elk-options.generated.d.ts
+interface ElkLayeredOptionValueByName {
+  "spacing.commentComment"?: number;
+  "spacing.commentNode"?: number;
+  "spacing.componentComponent"?: number;
+  "spacing.edgeEdge"?: number;
+  "spacing.edgeLabel"?: number;
+  "spacing.edgeNode"?: number;
+  "spacing.labelLabel"?: number;
+  "spacing.labelPortHorizontal"?: number;
+  "spacing.labelPortVertical"?: number;
+  "spacing.labelNode"?: number;
+  "spacing.node"?: number;
+  "spacing.nodeSelfLoop"?: number;
+  "spacing.portPort"?: number;
+  "spacing.individual"?: unknown;
+  "spacing.baseValue"?: number;
+  "spacing.edgeEdgeBetweenLayers"?: number;
+  "spacing.edgeNodeBetweenLayers"?: number;
+  "spacing.layer"?: number;
+  "priority"?: number;
+  "priority.direction"?: number;
+  "priority.shortness"?: number;
+  "priority.straightness"?: number;
+  "wrapping.strategy"?: string;
+  "wrapping.additionalEdgeSpacing"?: number;
+  "wrapping.correctionFactor"?: number;
+  "wrapping.cutting.strategy"?: string;
+  "wrapping.cutting.cuts"?: unknown;
+  "wrapping.cutting.msd.freedom"?: number;
+  "wrapping.validify.strategy"?: string;
+  "wrapping.validify.forbiddenIndices"?: unknown;
+  "wrapping.multiEdge.improveCuts"?: boolean;
+  "wrapping.multiEdge.distancePenalty"?: number;
+  "wrapping.multiEdge.improveWrappedEdges"?: boolean;
+  "layerUnzipping.strategy"?: string;
+  "layerUnzipping.minimizeEdgeLength"?: boolean;
+  "layerUnzipping.layerSplit"?: number;
+  "layerUnzipping.resetOnLongEdges"?: boolean;
+  "nodePlacement.networkSimplex.nodeFlexibility"?: string;
+  "nodePlacement.networkSimplex.nodeFlexibility.default"?: string;
+  "edgeRouting.splines.mode"?: string;
+  "edgeRouting.splines.sloppy.layerSpacingFactor"?: number;
+  "topdownLayout"?: boolean;
+  "topdown.scaleFactor"?: number;
+  "topdown.hierarchicalNodeWidth"?: number;
+  "topdown.hierarchicalNodeAspectRatio"?: number;
+  "topdown.nodeType"?: string;
+  "padding"?: unknown;
+  "edgeRouting"?: string;
+  "port.borderOffset"?: number;
+  "randomSeed"?: number;
+  "aspectRatio"?: number;
+  "noLayout"?: boolean;
+  "portConstraints"?: string;
+  "port.side"?: string;
+  "debugMode"?: boolean;
+  "alignment"?: string;
+  "hierarchyHandling"?: string;
+  "separateConnectedComponents"?: boolean;
+  "insideSelfLoops.activate"?: boolean;
+  "insideSelfLoops.yo"?: boolean;
+  "nodeSize.constraints"?: string;
+  "nodeSize.options"?: string;
+  "nodeSize.fixedGraphSize"?: boolean;
+  "direction"?: string;
+  "nodeLabels.placement"?: string;
+  "nodeLabels.padding"?: unknown;
+  "portLabels.placement"?: string;
+  "portLabels.nextToPortIfPossible"?: boolean;
+  "portLabels.treatAsGroup"?: boolean;
+  "portAlignment.default"?: string;
+  "portAlignment.north"?: string;
+  "portAlignment.south"?: string;
+  "portAlignment.west"?: string;
+  "portAlignment.east"?: string;
+  "unnecessaryBendpoints"?: boolean;
+  "layering.strategy"?: string;
+  "layering.nodePromotion.strategy"?: string;
+  "thoroughness"?: number;
+  "layering.layerConstraint"?: string;
+  "cycleBreaking.strategy"?: string;
+  "crossingMinimization.strategy"?: string;
+  "crossingMinimization.forceNodeModelOrder"?: boolean;
+  "crossingMinimization.greedySwitch.activationThreshold"?: number;
+  "crossingMinimization.greedySwitch.type"?: string;
+  "crossingMinimization.greedySwitchHierarchical.type"?: string;
+  "crossingMinimization.semiInteractive"?: boolean;
+  "mergeEdges"?: boolean;
+  "mergeHierarchyEdges"?: boolean;
+  "interactiveReferencePoint"?: string;
+  "nodePlacement.strategy"?: string;
+  "nodePlacement.bk.fixedAlignment"?: string;
+  "feedbackEdges"?: boolean;
+  "nodePlacement.linearSegments.deflectionDampening"?: number;
+  "edgeRouting.selfLoopDistribution"?: string;
+  "edgeRouting.selfLoopOrdering"?: string;
+  "contentAlignment"?: string;
+  "nodePlacement.bk.edgeStraightening"?: string;
+  "compaction.postCompaction.strategy"?: string;
+  "compaction.postCompaction.constraints"?: string;
+  "compaction.connectedComponents"?: boolean;
+  "highDegreeNodes.treatment"?: boolean;
+  "highDegreeNodes.threshold"?: number;
+  "highDegreeNodes.treeHeight"?: number;
+  "nodeSize.minimum"?: unknown;
+  "junctionPoints"?: unknown;
+  "edge.thickness"?: number;
+  "edgeLabels.placement"?: string;
+  "edgeLabels.inline"?: boolean;
+  "crossingMinimization.hierarchicalSweepiness"?: number;
+  "port.index"?: number;
+  "commentBox"?: boolean;
+  "hypernode"?: boolean;
+  "port.anchor"?: unknown;
+  "partitioning.activate"?: boolean;
+  "partitioning.partition"?: number;
+  "layering.minWidth.upperBoundOnWidth"?: number;
+  "layering.minWidth.upperLayerEstimationScalingFactor"?: number;
+  "position"?: unknown;
+  "allowNonFlowPortsToSwitchSides"?: boolean;
+  "layering.nodePromotion.maxIterations"?: number;
+  "edgeLabels.sideSelection"?: string;
+  "edgeLabels.centerLabelPlacementStrategy"?: string;
+  "margins"?: unknown;
+  "layering.coffmanGraham.layerBound"?: number;
+  "nodePlacement.favorStraightEdges"?: boolean;
+  "spacing.portsSurrounding"?: unknown;
+  "directionCongruency"?: string;
+  "portSortingStrategy"?: string;
+  "edgeRouting.polyline.slopedEdgeZoneWidth"?: number;
+  "crossingMinimization.inLayerPredOf"?: string;
+  "crossingMinimization.inLayerSuccOf"?: string;
+  "layering.layerChoiceConstraint"?: number;
+  "crossingMinimization.positionChoiceConstraint"?: number;
+  "interactiveLayout"?: boolean;
+  "layering.layerId"?: number;
+  "crossingMinimization.positionId"?: number;
+  "considerModelOrder.strategy"?: string;
+  "considerModelOrder.longEdgeStrategy"?: string;
+  "considerModelOrder.crossingCounterNodeInfluence"?: number;
+  "considerModelOrder.crossingCounterPortInfluence"?: number;
+  "considerModelOrder.noModelOrder"?: boolean;
+  "considerModelOrder.components"?: string;
+  "considerModelOrder.portModelOrder"?: boolean;
+  "considerModelOrder.groupModelOrder.cycleBreakingId"?: number;
+  "considerModelOrder.groupModelOrder.crossingMinimizationId"?: number;
+  "considerModelOrder.groupModelOrder.componentGroupId"?: number;
+  "considerModelOrder.groupModelOrder.cbGroupOrderStrategy"?: string;
+  "considerModelOrder.groupModelOrder.cmGroupOrderStrategy"?: string;
+  "considerModelOrder.groupModelOrder.cmEnforcedGroupOrders"?: unknown;
+  "considerModelOrder.groupModelOrder.cbPreferredSourceId"?: number;
+  "considerModelOrder.groupModelOrder.cbPreferredTargetId"?: number;
+  "generatePositionAndLayerIds"?: boolean;
+}
+declare const elkLayeredOptionDefinitions: readonly [{
+  readonly name: "spacing.commentComment";
+  readonly elkId: "org.eclipse.elk.spacing.commentComment";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.commentNode";
+  readonly elkId: "org.eclipse.elk.spacing.commentNode";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.componentComponent";
+  readonly elkId: "org.eclipse.elk.spacing.componentComponent";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.edgeEdge";
+  readonly elkId: "org.eclipse.elk.spacing.edgeEdge";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.edgeLabel";
+  readonly elkId: "org.eclipse.elk.spacing.edgeLabel";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.edgeNode";
+  readonly elkId: "org.eclipse.elk.spacing.edgeNode";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.labelLabel";
+  readonly elkId: "org.eclipse.elk.spacing.labelLabel";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.labelPortHorizontal";
+  readonly elkId: "org.eclipse.elk.spacing.labelPortHorizontal";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.labelPortVertical";
+  readonly elkId: "org.eclipse.elk.spacing.labelPortVertical";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.labelNode";
+  readonly elkId: "org.eclipse.elk.spacing.labelNode";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.node";
+  readonly elkId: "org.eclipse.elk.spacing.nodeNode";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.nodeSelfLoop";
+  readonly elkId: "org.eclipse.elk.spacing.nodeSelfLoop";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.portPort";
+  readonly elkId: "org.eclipse.elk.spacing.portPort";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS", "NODES"];
+}, {
+  readonly name: "spacing.individual";
+  readonly elkId: "org.eclipse.elk.spacing.individual";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["NODES", "EDGES", "PORTS", "LABELS"];
+}, {
+  readonly name: "spacing.baseValue";
+  readonly elkId: "org.eclipse.elk.layered.spacing.baseValue";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.edgeEdgeBetweenLayers";
+  readonly elkId: "org.eclipse.elk.layered.spacing.edgeEdgeBetweenLayers";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.edgeNodeBetweenLayers";
+  readonly elkId: "org.eclipse.elk.layered.spacing.edgeNodeBetweenLayers";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.layer";
+  readonly elkId: "org.eclipse.elk.layered.spacing.nodeNodeBetweenLayers";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "priority";
+  readonly elkId: "org.eclipse.elk.priority";
+  readonly type: "INT";
+  readonly targets: readonly ["NODES", "EDGES"];
+}, {
+  readonly name: "priority.direction";
+  readonly elkId: "org.eclipse.elk.layered.priority.direction";
+  readonly type: "INT";
+  readonly targets: readonly ["EDGES"];
+}, {
+  readonly name: "priority.shortness";
+  readonly elkId: "org.eclipse.elk.layered.priority.shortness";
+  readonly type: "INT";
+  readonly targets: readonly ["EDGES"];
+}, {
+  readonly name: "priority.straightness";
+  readonly elkId: "org.eclipse.elk.layered.priority.straightness";
+  readonly type: "INT";
+  readonly targets: readonly ["EDGES"];
+}, {
+  readonly name: "wrapping.strategy";
+  readonly elkId: "org.eclipse.elk.layered.wrapping.strategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "wrapping.additionalEdgeSpacing";
+  readonly elkId: "org.eclipse.elk.layered.wrapping.additionalEdgeSpacing";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "wrapping.correctionFactor";
+  readonly elkId: "org.eclipse.elk.layered.wrapping.correctionFactor";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "wrapping.cutting.strategy";
+  readonly elkId: "org.eclipse.elk.layered.wrapping.cutting.strategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "wrapping.cutting.cuts";
+  readonly elkId: "org.eclipse.elk.layered.wrapping.cutting.cuts";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "wrapping.cutting.msd.freedom";
+  readonly elkId: "org.eclipse.elk.layered.wrapping.cutting.msd.freedom";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "wrapping.validify.strategy";
+  readonly elkId: "org.eclipse.elk.layered.wrapping.validify.strategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "wrapping.validify.forbiddenIndices";
+  readonly elkId: "org.eclipse.elk.layered.wrapping.validify.forbiddenIndices";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "wrapping.multiEdge.improveCuts";
+  readonly elkId: "org.eclipse.elk.layered.wrapping.multiEdge.improveCuts";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "wrapping.multiEdge.distancePenalty";
+  readonly elkId: "org.eclipse.elk.layered.wrapping.multiEdge.distancePenalty";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "wrapping.multiEdge.improveWrappedEdges";
+  readonly elkId: "org.eclipse.elk.layered.wrapping.multiEdge.improveWrappedEdges";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "layerUnzipping.strategy";
+  readonly elkId: "org.eclipse.elk.layered.layerUnzipping.strategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "layerUnzipping.minimizeEdgeLength";
+  readonly elkId: "org.eclipse.elk.layered.layerUnzipping.minimizeEdgeLength";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "layerUnzipping.layerSplit";
+  readonly elkId: "org.eclipse.elk.layered.layerUnzipping.layerSplit";
+  readonly type: "INT";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "layerUnzipping.resetOnLongEdges";
+  readonly elkId: "org.eclipse.elk.layered.layerUnzipping.resetOnLongEdges";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "nodePlacement.networkSimplex.nodeFlexibility";
+  readonly elkId: "org.eclipse.elk.layered.nodePlacement.networkSimplex.nodeFlexibility";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "nodePlacement.networkSimplex.nodeFlexibility.default";
+  readonly elkId: "org.eclipse.elk.layered.nodePlacement.networkSimplex.nodeFlexibility.default";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "edgeRouting.splines.mode";
+  readonly elkId: "org.eclipse.elk.layered.edgeRouting.splines.mode";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "edgeRouting.splines.sloppy.layerSpacingFactor";
+  readonly elkId: "org.eclipse.elk.layered.edgeRouting.splines.sloppy.layerSpacingFactor";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "topdownLayout";
+  readonly elkId: "org.eclipse.elk.topdownLayout";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "topdown.scaleFactor";
+  readonly elkId: "org.eclipse.elk.topdown.scaleFactor";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "topdown.hierarchicalNodeWidth";
+  readonly elkId: "org.eclipse.elk.topdown.hierarchicalNodeWidth";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS", "NODES"];
+}, {
+  readonly name: "topdown.hierarchicalNodeAspectRatio";
+  readonly elkId: "org.eclipse.elk.topdown.hierarchicalNodeAspectRatio";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS", "NODES"];
+}, {
+  readonly name: "topdown.nodeType";
+  readonly elkId: "org.eclipse.elk.topdown.nodeType";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "padding";
+  readonly elkId: "org.eclipse.elk.padding";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["PARENTS", "NODES"];
+}, {
+  readonly name: "edgeRouting";
+  readonly elkId: "org.eclipse.elk.edgeRouting";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "port.borderOffset";
+  readonly elkId: "org.eclipse.elk.port.borderOffset";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PORTS"];
+}, {
+  readonly name: "randomSeed";
+  readonly elkId: "org.eclipse.elk.randomSeed";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "aspectRatio";
+  readonly elkId: "org.eclipse.elk.aspectRatio";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "noLayout";
+  readonly elkId: "org.eclipse.elk.noLayout";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["NODES", "EDGES", "PORTS", "LABELS"];
+}, {
+  readonly name: "portConstraints";
+  readonly elkId: "org.eclipse.elk.portConstraints";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "port.side";
+  readonly elkId: "org.eclipse.elk.port.side";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PORTS"];
+}, {
+  readonly name: "debugMode";
+  readonly elkId: "org.eclipse.elk.debugMode";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "alignment";
+  readonly elkId: "org.eclipse.elk.alignment";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "hierarchyHandling";
+  readonly elkId: "org.eclipse.elk.hierarchyHandling";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS", "NODES"];
+}, {
+  readonly name: "separateConnectedComponents";
+  readonly elkId: "org.eclipse.elk.separateConnectedComponents";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "insideSelfLoops.activate";
+  readonly elkId: "org.eclipse.elk.insideSelfLoops.activate";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "insideSelfLoops.yo";
+  readonly elkId: "org.eclipse.elk.insideSelfLoops.yo";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["EDGES"];
+}, {
+  readonly name: "nodeSize.constraints";
+  readonly elkId: "org.eclipse.elk.nodeSize.constraints";
+  readonly type: "ENUMSET";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "nodeSize.options";
+  readonly elkId: "org.eclipse.elk.nodeSize.options";
+  readonly type: "ENUMSET";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "nodeSize.fixedGraphSize";
+  readonly elkId: "org.eclipse.elk.nodeSize.fixedGraphSize";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "direction";
+  readonly elkId: "org.eclipse.elk.direction";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "nodeLabels.placement";
+  readonly elkId: "org.eclipse.elk.nodeLabels.placement";
+  readonly type: "ENUMSET";
+  readonly targets: readonly ["NODES", "LABELS"];
+}, {
+  readonly name: "nodeLabels.padding";
+  readonly elkId: "org.eclipse.elk.nodeLabels.padding";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "portLabels.placement";
+  readonly elkId: "org.eclipse.elk.portLabels.placement";
+  readonly type: "ENUMSET";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "portLabels.nextToPortIfPossible";
+  readonly elkId: "org.eclipse.elk.portLabels.nextToPortIfPossible";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "portLabels.treatAsGroup";
+  readonly elkId: "org.eclipse.elk.portLabels.treatAsGroup";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "portAlignment.default";
+  readonly elkId: "org.eclipse.elk.portAlignment.default";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "portAlignment.north";
+  readonly elkId: "org.eclipse.elk.portAlignment.north";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "portAlignment.south";
+  readonly elkId: "org.eclipse.elk.portAlignment.south";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "portAlignment.west";
+  readonly elkId: "org.eclipse.elk.portAlignment.west";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "portAlignment.east";
+  readonly elkId: "org.eclipse.elk.portAlignment.east";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "unnecessaryBendpoints";
+  readonly elkId: "org.eclipse.elk.layered.unnecessaryBendpoints";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "layering.strategy";
+  readonly elkId: "org.eclipse.elk.layered.layering.strategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "layering.nodePromotion.strategy";
+  readonly elkId: "org.eclipse.elk.layered.layering.nodePromotion.strategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "thoroughness";
+  readonly elkId: "org.eclipse.elk.layered.thoroughness";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "layering.layerConstraint";
+  readonly elkId: "org.eclipse.elk.layered.layering.layerConstraint";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "cycleBreaking.strategy";
+  readonly elkId: "org.eclipse.elk.layered.cycleBreaking.strategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "crossingMinimization.strategy";
+  readonly elkId: "org.eclipse.elk.layered.crossingMinimization.strategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "crossingMinimization.forceNodeModelOrder";
+  readonly elkId: "org.eclipse.elk.layered.crossingMinimization.forceNodeModelOrder";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "crossingMinimization.greedySwitch.activationThreshold";
+  readonly elkId: "org.eclipse.elk.layered.crossingMinimization.greedySwitch.activationThreshold";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "crossingMinimization.greedySwitch.type";
+  readonly elkId: "org.eclipse.elk.layered.crossingMinimization.greedySwitch.type";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "crossingMinimization.greedySwitchHierarchical.type";
+  readonly elkId: "org.eclipse.elk.layered.crossingMinimization.greedySwitchHierarchical.type";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "crossingMinimization.semiInteractive";
+  readonly elkId: "org.eclipse.elk.layered.crossingMinimization.semiInteractive";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "mergeEdges";
+  readonly elkId: "org.eclipse.elk.layered.mergeEdges";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "mergeHierarchyEdges";
+  readonly elkId: "org.eclipse.elk.layered.mergeHierarchyEdges";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "interactiveReferencePoint";
+  readonly elkId: "org.eclipse.elk.layered.interactiveReferencePoint";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "nodePlacement.strategy";
+  readonly elkId: "org.eclipse.elk.layered.nodePlacement.strategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "nodePlacement.bk.fixedAlignment";
+  readonly elkId: "org.eclipse.elk.layered.nodePlacement.bk.fixedAlignment";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "feedbackEdges";
+  readonly elkId: "org.eclipse.elk.layered.feedbackEdges";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "nodePlacement.linearSegments.deflectionDampening";
+  readonly elkId: "org.eclipse.elk.layered.nodePlacement.linearSegments.deflectionDampening";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "edgeRouting.selfLoopDistribution";
+  readonly elkId: "org.eclipse.elk.layered.edgeRouting.selfLoopDistribution";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "edgeRouting.selfLoopOrdering";
+  readonly elkId: "org.eclipse.elk.layered.edgeRouting.selfLoopOrdering";
+  readonly type: "ENUM";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "contentAlignment";
+  readonly elkId: "org.eclipse.elk.contentAlignment";
+  readonly type: "ENUMSET";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "nodePlacement.bk.edgeStraightening";
+  readonly elkId: "org.eclipse.elk.layered.nodePlacement.bk.edgeStraightening";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "compaction.postCompaction.strategy";
+  readonly elkId: "org.eclipse.elk.layered.compaction.postCompaction.strategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "compaction.postCompaction.constraints";
+  readonly elkId: "org.eclipse.elk.layered.compaction.postCompaction.constraints";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "compaction.connectedComponents";
+  readonly elkId: "org.eclipse.elk.layered.compaction.connectedComponents";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "highDegreeNodes.treatment";
+  readonly elkId: "org.eclipse.elk.layered.highDegreeNodes.treatment";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "highDegreeNodes.threshold";
+  readonly elkId: "org.eclipse.elk.layered.highDegreeNodes.threshold";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "highDegreeNodes.treeHeight";
+  readonly elkId: "org.eclipse.elk.layered.highDegreeNodes.treeHeight";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "nodeSize.minimum";
+  readonly elkId: "org.eclipse.elk.nodeSize.minimum";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "junctionPoints";
+  readonly elkId: "org.eclipse.elk.junctionPoints";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["EDGES"];
+}, {
+  readonly name: "edge.thickness";
+  readonly elkId: "org.eclipse.elk.edge.thickness";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["EDGES"];
+}, {
+  readonly name: "edgeLabels.placement";
+  readonly elkId: "org.eclipse.elk.edgeLabels.placement";
+  readonly type: "ENUM";
+  readonly targets: readonly ["LABELS"];
+}, {
+  readonly name: "edgeLabels.inline";
+  readonly elkId: "org.eclipse.elk.edgeLabels.inline";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["LABELS"];
+}, {
+  readonly name: "crossingMinimization.hierarchicalSweepiness";
+  readonly elkId: "org.eclipse.elk.layered.crossingMinimization.hierarchicalSweepiness";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "port.index";
+  readonly elkId: "org.eclipse.elk.port.index";
+  readonly type: "INT";
+  readonly targets: readonly ["PORTS"];
+}, {
+  readonly name: "commentBox";
+  readonly elkId: "org.eclipse.elk.commentBox";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "hypernode";
+  readonly elkId: "org.eclipse.elk.hypernode";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "port.anchor";
+  readonly elkId: "org.eclipse.elk.port.anchor";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["PORTS"];
+}, {
+  readonly name: "partitioning.activate";
+  readonly elkId: "org.eclipse.elk.partitioning.activate";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "partitioning.partition";
+  readonly elkId: "org.eclipse.elk.partitioning.partition";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS", "NODES"];
+}, {
+  readonly name: "layering.minWidth.upperBoundOnWidth";
+  readonly elkId: "org.eclipse.elk.layered.layering.minWidth.upperBoundOnWidth";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "layering.minWidth.upperLayerEstimationScalingFactor";
+  readonly elkId: "org.eclipse.elk.layered.layering.minWidth.upperLayerEstimationScalingFactor";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "position";
+  readonly elkId: "org.eclipse.elk.position";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["NODES", "PORTS", "LABELS"];
+}, {
+  readonly name: "allowNonFlowPortsToSwitchSides";
+  readonly elkId: "org.eclipse.elk.layered.allowNonFlowPortsToSwitchSides";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PORTS"];
+}, {
+  readonly name: "layering.nodePromotion.maxIterations";
+  readonly elkId: "org.eclipse.elk.layered.layering.nodePromotion.maxIterations";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "edgeLabels.sideSelection";
+  readonly elkId: "org.eclipse.elk.layered.edgeLabels.sideSelection";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "edgeLabels.centerLabelPlacementStrategy";
+  readonly elkId: "org.eclipse.elk.layered.edgeLabels.centerLabelPlacementStrategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS", "LABELS"];
+}, {
+  readonly name: "margins";
+  readonly elkId: "org.eclipse.elk.margins";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "layering.coffmanGraham.layerBound";
+  readonly elkId: "org.eclipse.elk.layered.layering.coffmanGraham.layerBound";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "nodePlacement.favorStraightEdges";
+  readonly elkId: "org.eclipse.elk.layered.nodePlacement.favorStraightEdges";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "spacing.portsSurrounding";
+  readonly elkId: "org.eclipse.elk.spacing.portsSurrounding";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "directionCongruency";
+  readonly elkId: "org.eclipse.elk.layered.directionCongruency";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "portSortingStrategy";
+  readonly elkId: "org.eclipse.elk.layered.portSortingStrategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "edgeRouting.polyline.slopedEdgeZoneWidth";
+  readonly elkId: "org.eclipse.elk.layered.edgeRouting.polyline.slopedEdgeZoneWidth";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "crossingMinimization.inLayerPredOf";
+  readonly elkId: "org.eclipse.elk.layered.crossingMinimization.inLayerPredOf";
+  readonly type: "STRING";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "crossingMinimization.inLayerSuccOf";
+  readonly elkId: "org.eclipse.elk.layered.crossingMinimization.inLayerSuccOf";
+  readonly type: "STRING";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "layering.layerChoiceConstraint";
+  readonly elkId: "org.eclipse.elk.layered.layering.layerChoiceConstraint";
+  readonly type: "INT";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "crossingMinimization.positionChoiceConstraint";
+  readonly elkId: "org.eclipse.elk.layered.crossingMinimization.positionChoiceConstraint";
+  readonly type: "INT";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "interactiveLayout";
+  readonly elkId: "org.eclipse.elk.interactiveLayout";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "layering.layerId";
+  readonly elkId: "org.eclipse.elk.layered.layering.layerId";
+  readonly type: "INT";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "crossingMinimization.positionId";
+  readonly elkId: "org.eclipse.elk.layered.crossingMinimization.positionId";
+  readonly type: "INT";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "considerModelOrder.strategy";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.strategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "considerModelOrder.longEdgeStrategy";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.longEdgeStrategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "considerModelOrder.crossingCounterNodeInfluence";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.crossingCounterNodeInfluence";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "considerModelOrder.crossingCounterPortInfluence";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.crossingCounterPortInfluence";
+  readonly type: "DOUBLE";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "considerModelOrder.noModelOrder";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.noModelOrder";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "considerModelOrder.components";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.components";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "considerModelOrder.portModelOrder";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.portModelOrder";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "considerModelOrder.groupModelOrder.cycleBreakingId";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cycleBreakingId";
+  readonly type: "INT";
+  readonly targets: readonly ["NODES"];
+}, {
+  readonly name: "considerModelOrder.groupModelOrder.crossingMinimizationId";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.crossingMinimizationId";
+  readonly type: "INT";
+  readonly targets: readonly ["NODES", "EDGES", "PORTS"];
+}, {
+  readonly name: "considerModelOrder.groupModelOrder.componentGroupId";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.componentGroupId";
+  readonly type: "INT";
+  readonly targets: readonly ["NODES", "EDGES", "PORTS"];
+}, {
+  readonly name: "considerModelOrder.groupModelOrder.cbGroupOrderStrategy";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cbGroupOrderStrategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "considerModelOrder.groupModelOrder.cmGroupOrderStrategy";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cmGroupOrderStrategy";
+  readonly type: "ENUM";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "considerModelOrder.groupModelOrder.cmEnforcedGroupOrders";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cmEnforcedGroupOrders";
+  readonly type: "OBJECT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "considerModelOrder.groupModelOrder.cbPreferredSourceId";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cbPreferredSourceId";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "considerModelOrder.groupModelOrder.cbPreferredTargetId";
+  readonly elkId: "org.eclipse.elk.layered.considerModelOrder.groupModelOrder.cbPreferredTargetId";
+  readonly type: "INT";
+  readonly targets: readonly ["PARENTS"];
+}, {
+  readonly name: "generatePositionAndLayerIds";
+  readonly elkId: "org.eclipse.elk.layered.generatePositionAndLayerIds";
+  readonly type: "BOOLEAN";
+  readonly targets: readonly ["PARENTS"];
+}];
+type ElkLayeredOptionName = keyof ElkLayeredOptionValueByName;
+type ElkLayeredOptionId = (typeof elkLayeredOptionDefinitions)[number]["elkId"];
+//#endregion
+//#region src/layered/elk-enum-values.d.ts
+/** Every ELK 0.11.1 enum constant, source-locked to its Java declaration. */
+declare const elkLayeredEnumValues: {
+  readonly "wrapping.strategy": readonly ["OFF", "SINGLE_EDGE", "MULTI_EDGE"];
+  readonly "wrapping.cutting.strategy": readonly ["ARD", "MSD", "MANUAL"];
+  readonly "wrapping.validify.strategy": readonly ["NO", "GREEDY", "LOOK_BACK"];
+  readonly "layerUnzipping.strategy": readonly ["NONE", "ALTERNATING"];
+  readonly "nodePlacement.networkSimplex.nodeFlexibility": readonly ["NONE", "PORT_POSITION", "NODE_SIZE_WHERE_SPACE_PERMITS", "NODE_SIZE"];
+  readonly "nodePlacement.networkSimplex.nodeFlexibility.default": readonly ["NONE", "PORT_POSITION", "NODE_SIZE_WHERE_SPACE_PERMITS", "NODE_SIZE"];
+  readonly "edgeRouting.splines.mode": readonly ["CONSERVATIVE", "CONSERVATIVE_SOFT", "SLOPPY"];
+  readonly "topdown.nodeType": readonly ["PARALLEL_NODE", "HIERARCHICAL_NODE", "ROOT_NODE"];
+  readonly edgeRouting: readonly ["UNDEFINED", "POLYLINE", "ORTHOGONAL", "SPLINES"];
+  readonly portConstraints: readonly ["UNDEFINED", "FREE", "FIXED_SIDE", "FIXED_ORDER", "FIXED_RATIO", "FIXED_POS"];
+  readonly "port.side": readonly ["UNDEFINED", "NORTH", "EAST", "SOUTH", "WEST"];
+  readonly alignment: readonly ["AUTOMATIC", "LEFT", "RIGHT", "TOP", "BOTTOM", "CENTER"];
+  readonly hierarchyHandling: readonly ["INHERIT", "INCLUDE_CHILDREN", "SEPARATE_CHILDREN"];
+  readonly "nodeSize.constraints": readonly ["PORTS", "PORT_LABELS", "NODE_LABELS", "MINIMUM_SIZE"];
+  readonly "nodeSize.options": readonly ["DEFAULT_MINIMUM_SIZE", "MINIMUM_SIZE_ACCOUNTS_FOR_PADDING", "COMPUTE_PADDING", "OUTSIDE_NODE_LABELS_OVERHANG", "PORTS_OVERHANG", "UNIFORM_PORT_SPACING", "SPACE_EFFICIENT_PORT_LABELS", "FORCE_TABULAR_NODE_LABELS", "ASYMMETRICAL"];
+  readonly direction: readonly ["UNDEFINED", "RIGHT", "LEFT", "DOWN", "UP"];
+  readonly "nodeLabels.placement": readonly ["H_LEFT", "H_CENTER", "H_RIGHT", "V_TOP", "V_CENTER", "V_BOTTOM", "INSIDE", "OUTSIDE", "H_PRIORITY"];
+  readonly "portLabels.placement": readonly ["OUTSIDE", "INSIDE", "NEXT_TO_PORT_IF_POSSIBLE", "ALWAYS_SAME_SIDE", "ALWAYS_OTHER_SAME_SIDE", "SPACE_EFFICIENT"];
+  readonly "portAlignment.default": readonly ["DISTRIBUTED", "JUSTIFIED", "BEGIN", "CENTER", "END"];
+  readonly "portAlignment.north": readonly ["DISTRIBUTED", "JUSTIFIED", "BEGIN", "CENTER", "END"];
+  readonly "portAlignment.south": readonly ["DISTRIBUTED", "JUSTIFIED", "BEGIN", "CENTER", "END"];
+  readonly "portAlignment.west": readonly ["DISTRIBUTED", "JUSTIFIED", "BEGIN", "CENTER", "END"];
+  readonly "portAlignment.east": readonly ["DISTRIBUTED", "JUSTIFIED", "BEGIN", "CENTER", "END"];
+  readonly "layering.strategy": readonly ["NETWORK_SIMPLEX", "LONGEST_PATH", "LONGEST_PATH_SOURCE", "COFFMAN_GRAHAM", "INTERACTIVE", "STRETCH_WIDTH", "MIN_WIDTH", "BF_MODEL_ORDER", "DF_MODEL_ORDER"];
+  readonly "layering.nodePromotion.strategy": readonly ["NONE", "NIKOLOV", "NIKOLOV_PIXEL", "NIKOLOV_IMPROVED", "NIKOLOV_IMPROVED_PIXEL", "DUMMYNODE_PERCENTAGE", "NODECOUNT_PERCENTAGE", "NO_BOUNDARY", "MODEL_ORDER_LEFT_TO_RIGHT", "MODEL_ORDER_RIGHT_TO_LEFT"];
+  readonly "layering.layerConstraint": readonly ["NONE", "FIRST", "FIRST_SEPARATE", "LAST", "LAST_SEPARATE"];
+  readonly "cycleBreaking.strategy": readonly ["GREEDY", "DEPTH_FIRST", "INTERACTIVE", "MODEL_ORDER", "GREEDY_MODEL_ORDER", "SCC_CONNECTIVITY", "SCC_NODE_TYPE", "DFS_NODE_ORDER", "BFS_NODE_ORDER"];
+  readonly "crossingMinimization.strategy": readonly ["LAYER_SWEEP", "MEDIAN_LAYER_SWEEP", "INTERACTIVE", "NONE"];
+  readonly "crossingMinimization.greedySwitch.type": readonly ["ONE_SIDED", "TWO_SIDED", "OFF"];
+  readonly "crossingMinimization.greedySwitchHierarchical.type": readonly ["ONE_SIDED", "TWO_SIDED", "OFF"];
+  readonly interactiveReferencePoint: readonly ["CENTER", "TOP_LEFT"];
+  readonly "nodePlacement.strategy": readonly ["SIMPLE", "INTERACTIVE", "LINEAR_SEGMENTS", "BRANDES_KOEPF", "NETWORK_SIMPLEX"];
+  readonly "nodePlacement.bk.fixedAlignment": readonly ["NONE", "LEFTUP", "RIGHTUP", "LEFTDOWN", "RIGHTDOWN", "BALANCED"];
+  readonly "edgeRouting.selfLoopDistribution": readonly ["EQUALLY", "NORTH", "NORTH_SOUTH"];
+  readonly "edgeRouting.selfLoopOrdering": readonly ["STACKED", "REVERSE_STACKED", "SEQUENCED"];
+  readonly contentAlignment: readonly ["V_TOP", "V_CENTER", "V_BOTTOM", "H_LEFT", "H_CENTER", "H_RIGHT"];
+  readonly "nodePlacement.bk.edgeStraightening": readonly ["NONE", "IMPROVE_STRAIGHTNESS"];
+  readonly "compaction.postCompaction.strategy": readonly ["NONE", "LEFT", "RIGHT", "LEFT_RIGHT_CONSTRAINT_LOCKING", "LEFT_RIGHT_CONNECTION_LOCKING", "EDGE_LENGTH"];
+  readonly "compaction.postCompaction.constraints": readonly ["QUADRATIC", "SCANLINE"];
+  readonly "edgeLabels.placement": readonly ["CENTER", "HEAD", "TAIL"];
+  readonly "edgeLabels.sideSelection": readonly ["ALWAYS_UP", "ALWAYS_DOWN", "DIRECTION_UP", "DIRECTION_DOWN", "SMART_UP", "SMART_DOWN"];
+  readonly "edgeLabels.centerLabelPlacementStrategy": readonly ["MEDIAN_LAYER", "TAIL_LAYER", "HEAD_LAYER", "SPACE_EFFICIENT_LAYER", "WIDEST_LAYER", "CENTER_LAYER"];
+  readonly directionCongruency: readonly ["READING_DIRECTION", "ROTATION"];
+  readonly portSortingStrategy: readonly ["INPUT_ORDER", "PORT_DEGREE"];
+  readonly "considerModelOrder.strategy": readonly ["NONE", "NODES_AND_EDGES", "PREFER_EDGES", "PREFER_NODES"];
+  readonly "considerModelOrder.longEdgeStrategy": readonly ["DUMMY_NODE_OVER", "DUMMY_NODE_UNDER", "EQUAL"];
+  readonly "considerModelOrder.components": readonly ["NONE", "INSIDE_PORT_SIDE_GROUPS", "GROUP_MODEL_ORDER", "MODEL_ORDER"];
+  readonly "considerModelOrder.groupModelOrder.cbGroupOrderStrategy": readonly ["ONLY_WITHIN_GROUP", "MODEL_ORDER", "ENFORCED"];
+  readonly "considerModelOrder.groupModelOrder.cmGroupOrderStrategy": readonly ["ONLY_WITHIN_GROUP", "MODEL_ORDER", "ENFORCED"];
+};
+//#endregion
+//#region src/layered/elk-options.d.ts
+type CycleBreakingStrategy = (typeof elkLayeredEnumValues)["cycleBreaking.strategy"][number];
+type LayeringStrategy = (typeof elkLayeredEnumValues)["layering.strategy"][number];
+type CrossingMinimizationStrategy = (typeof elkLayeredEnumValues)["crossingMinimization.strategy"][number];
+type NodePlacementStrategy = (typeof elkLayeredEnumValues)["nodePlacement.strategy"][number];
+type EdgeRoutingStyle = (typeof elkLayeredEnumValues)["edgeRouting"][number];
+type StrictElkLayeredOptionValueByName = Omit<ElkLayeredOptionValueByName, keyof typeof elkLayeredEnumValues> & { [Name in keyof typeof elkLayeredEnumValues]?: (typeof elkLayeredEnumValues)[Name][number] };
+type LayeredAdvancedOptions = Omit<StrictElkLayeredOptionValueByName, "direction" | "padding" | "spacing.node" | "spacing.layer" | "cycleBreaking.strategy" | "layering.strategy" | "crossingMinimization.strategy" | "nodePlacement.strategy" | "edgeRouting"> & {
+  "cycleBreaking.strategy"?: CycleBreakingStrategy;
+  "layering.strategy"?: LayeringStrategy;
+  "crossingMinimization.strategy"?: CrossingMinimizationStrategy;
+  "nodePlacement.strategy"?: NodePlacementStrategy;
+  edgeRouting?: EdgeRoutingStyle;
+};
+/** Translate every simplified layered setting to its exact ELK 0.11.1 option ID. */
+declare function toElkLayeredOptions(options: LayeredLayoutOptions): Partial<Record<ElkLayeredOptionId, unknown>>;
+/** Return the simplified public name for an exact ELK layered option ID. */
+declare function fromElkLayeredOptionId(id: ElkLayeredOptionId): ElkLayeredOptionName;
+//#endregion
+//#region src/layered/types.d.ts
+interface NodeSize {
+  width: number;
+  height: number;
+}
+interface LayeredSpacing {
+  node: number;
+  layer: number;
+}
+interface LayoutPadding {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+interface LayeredPhaseInput {
+  graph: Graph<unknown, unknown, unknown, unknown>;
+  sizes: ReadonlyMap<string, NodeSize>;
+  direction: LayoutDirection;
+  spacing: LayeredSpacing;
+  padding: LayoutPadding;
+  constrainedLayerByNodeId: ReadonlyMap<string, number>;
+  settings: LayeredAdvancedOptions;
+  nodeSettings?: (node: GraphNode) => ElkLayeredOptionValueByName | undefined;
+  edgeSettings?: (edge: GraphEdge) => ElkLayeredOptionValueByName | undefined;
+  portSettings?: (port: GraphPort, node: GraphNode) => ElkLayeredOptionValueByName | undefined;
+}
+interface AcyclicOrientation {
+  reversedEdgeIds: ReadonlySet<string>;
+}
+interface LayerAssignment {
+  layerByNodeId: ReadonlyMap<string, number>;
+  /** Layer-internal seed order produced by layerers whose insertion order is observable. */
+  seedOrder?: readonly string[];
+}
+interface LayerOrder {
+  layers: readonly (readonly string[])[];
+  /** Internal ELK sweep state retained for exact port-aware placement. */
+  inputPortOrderByNodeId?: ReadonlyMap<string, readonly string[]>;
+  /** Internal ELK sweep state retained for exact port-aware placement. */
+  outputPortOrderByNodeId?: ReadonlyMap<string, readonly string[]>;
+}
+interface NodePlacement {
+  rectByNodeId: ReadonlyMap<string, EntityRect>;
+}
+interface EdgeRoutes {
+  pointsByEdgeId: ReadonlyMap<string, readonly Point[]>;
+  /** ELK spline segment NUB controls retained until long-edge joining. */
+  splineNubControlsByEdgeId?: ReadonlyMap<string, readonly Point[]>;
+}
+type CycleBreaker = (input: LayeredPhaseInput) => AcyclicOrientation;
+type LayerAssigner = (input: LayeredPhaseInput, orientation: AcyclicOrientation) => LayerAssignment;
+type CrossingMinimizer = (input: LayeredPhaseInput, orientation: AcyclicOrientation, assignment: LayerAssignment) => LayerOrder;
+type NodePlacer = (input: LayeredPhaseInput, order: LayerOrder) => NodePlacement;
+type EdgeRouter = (input: LayeredPhaseInput, orientation: AcyclicOrientation, placement: NodePlacement) => EdgeRoutes;
+interface LayeredStrategies {
+  breakCycles?: CycleBreaker;
+  assignLayers?: LayerAssigner;
+  minimizeCrossings?: CrossingMinimizer;
+  placeNodes?: NodePlacer;
+  routeEdges?: EdgeRouter;
+}
+interface LayeredLayoutOptions {
+  direction?: LayoutDirection;
+  spacing?: Partial<LayeredSpacing>;
+  padding?: number | Partial<LayoutPadding>;
+  constraints?: LayoutConstraints;
+  measure?: (node: GraphNode) => NodeSize;
+  crossingSweeps?: number;
+  strategies?: LayeredStrategies;
+  /** ELK-equivalent settings keyed by simplified names without vendor prefixes. */
+  settings?: LayeredAdvancedOptions;
+  /** Per-node settings for ELK options whose target is a node. */
+  nodeSettings?: (node: GraphNode) => ElkLayeredOptionValueByName | undefined;
+  /** Per-edge settings for ELK options whose target is an edge. */
+  edgeSettings?: (edge: GraphEdge) => ElkLayeredOptionValueByName | undefined;
+  /** Per-port settings for ELK options whose target is a port. */
+  portSettings?: (port: GraphPort, node: GraphNode) => ElkLayeredOptionValueByName | undefined;
+}
+//#endregion
+//#region src/layered/strategies.d.ts
+declare const breakCyclesWithDepthFirstSearch: CycleBreaker;
+declare const breakCyclesGreedily: CycleBreaker;
+declare const breakCyclesGreedilyByModelOrder: CycleBreaker;
+/** ELK MODEL_ORDER for flat graphs without FIRST/LAST layer constraints. */
+declare const breakCyclesByModelOrder: CycleBreaker;
+/** ELK INTERACTIVE: honor authored x-order, then remove any remaining DFS back edges. */
+declare const breakCyclesInteractively: CycleBreaker;
+declare const breakCyclesWithModelOrderDepthFirstSearch: CycleBreaker;
+/** ELK BFS_NODE_ORDER, with input node order as ELK's internal model order. */
+declare const breakCyclesWithModelOrderBreadthFirstSearch: CycleBreaker;
+declare const breakCyclesByStronglyConnectedConnectivity: CycleBreaker;
+declare const breakCyclesByStronglyConnectedNodeType: CycleBreaker;
+declare const assignLayersByLongestPath: LayerAssigner;
+/** ELK LONGEST_PATH: align sinks on the final layer. */
+declare const assignLayersByLongestPathToSink: LayerAssigner;
+/** ELK INTERACTIVE layering for normal flat nodes. */
+declare const assignLayersInteractively: LayerAssigner;
+/** ELK BF_MODEL_ORDER for normal flat nodes (label dummies are a later preprocessing slice). */
+declare const assignLayersByBreadthFirstModelOrder: LayerAssigner;
+/** ELK DF_MODEL_ORDER for normal flat nodes, before label-dummy insertion. */
+declare const assignLayersByDepthFirstModelOrder: LayerAssigner;
+/** ELK COFFMAN_GRAHAM for flat DAGs, including transitive reduction and layer bounds. */
+declare const assignLayersWithCoffmanGraham: LayerAssigner;
+declare function minimizeCrossingsWithBarycenter(sweeps?: number): CrossingMinimizer;
+declare function minimizeCrossingsWithMedian(sweeps?: number): CrossingMinimizer;
+declare const minimizeCrossingsWithModelOrder: CrossingMinimizer;
+declare const minimizeCrossingsInteractively: CrossingMinimizer;
+declare const placeNodesInLayers: NodePlacer;
+/** ELK INTERACTIVE placement for normal flat nodes, preserving cross-axis coordinates. */
+declare const placeNodesInteractively: NodePlacer;
+declare const routeEdgesOrthogonally: EdgeRouter;
+declare const routeEdgesWithPolylines: EdgeRouter;
+declare const routeEdgesWithSplines: EdgeRouter;
+//#endregion
+//#region src/layered/network-simplex.d.ts
+declare const assignLayersWithNetworkSimplex: LayerAssigner;
+//#endregion
+//#region src/layered/min-width.d.ts
+declare const assignLayersWithMinWidth: LayerAssigner;
+//#endregion
+//#region src/layered/stretch-width.d.ts
+declare const assignLayersWithStretchWidth: LayerAssigner;
+//#endregion
+//#region src/layered/bk-node-placement.d.ts
+/** ELK-compatible Brandes-Koepf placement for implicit center ports. */
+declare function placeNodesWithBrandesKoepf(input: LayeredPhaseInput, order: LayerOrder): NodePlacement;
+//#endregion
+//#region src/layered/linear-segments-node-placement.d.ts
+/** ELK-compatible force-based linear-segments placement. */
+declare function placeNodesWithLinearSegments(input: LayeredPhaseInput, order: LayerOrder): NodePlacement;
+//#endregion
+//#region src/layered/network-simplex-node-placement.d.ts
+/** ELK auxiliary-graph network-simplex placement for fixed-position ports. */
+declare function placeNodesWithNetworkSimplex(input: LayeredPhaseInput, order: LayerOrder): NodePlacement;
+//#endregion
+//#region src/layered/index.d.ts
+/**
+ * Deterministic native layered layout for an `@statelyai/graph` graph.
+ *
+ * Supports flat and nested graphs, cycles, ports, self-loops, four directions,
+ * custom phase strategies, and all layered edge-routing styles.
+ */
+declare function getLayeredLayout<N, E, G, P>(graph: Graph<N, E, G, P> | VisualGraph<N, E, G, P>, options?: LayeredLayoutOptions): VisualGraph<N, E, G, P>;
+declare const layeredAlgorithm: LayoutAlgorithm<LayeredLayoutOptions>;
+//#endregion
+export { LayeringStrategy as $, routeEdgesOrthogonally as A, LayerOrder as B, breakCyclesWithModelOrderDepthFirstSearch as C, minimizeCrossingsWithModelOrder as D, minimizeCrossingsWithMedian as E, CycleBreaker as F, LayoutPadding as G, LayeredPhaseInput as H, EdgeRouter as I, NodeSize as J, NodePlacement as K, EdgeRoutes as L, routeEdgesWithSplines as M, AcyclicOrientation as N, placeNodesInLayers as O, CrossingMinimizer as P, LayeredAdvancedOptions as Q, LayerAssigner as R, breakCyclesWithModelOrderBreadthFirstSearch as S, minimizeCrossingsWithBarycenter as T, LayeredSpacing as U, LayeredLayoutOptions as V, LayeredStrategies as W, CycleBreakingStrategy as X, CrossingMinimizationStrategy as Y, EdgeRoutingStyle as Z, breakCyclesByStronglyConnectedNodeType as _, LayoutResult as _t, placeNodesWithBrandesKoepf as a, ElkLayeredOptionName as at, breakCyclesInteractively as b, assignLayersWithNetworkSimplex as c, AnyGraph as ct, assignLayersByLongestPath as d, LayoutDiagnostic as dt, NodePlacementStrategy as et, assignLayersByLongestPathToSink as f, LayoutDirection as ft, breakCyclesByStronglyConnectedConnectivity as g, LayoutRequest as gt, breakCyclesByModelOrder as h, LayoutPhaseMetrics as ht, placeNodesWithLinearSegments as i, ElkLayeredOptionId as it, routeEdgesWithPolylines as j, placeNodesInteractively as k, assignLayersByBreadthFirstModelOrder as l, LayoutAlgorithm as lt, assignLayersWithCoffmanGraham as m, LayoutMetrics as mt, layeredAlgorithm as n, toElkLayeredOptions as nt, assignLayersWithStretchWidth as o, ElkLayeredOptionValueByName as ot, assignLayersInteractively as p, LayoutExecutionContext as pt, NodePlacer as q, placeNodesWithNetworkSimplex as r, elkLayeredEnumValues as rt, assignLayersWithMinWidth as s, elkLayeredOptionDefinitions as st, getLayeredLayout as t, fromElkLayeredOptionId as tt, assignLayersByDepthFirstModelOrder as u, LayoutCapabilities as ut, breakCyclesGreedily as v, LayoutScope as vt, minimizeCrossingsInteractively as w, breakCyclesWithDepthFirstSearch as x, breakCyclesGreedilyByModelOrder as y, LayerAssignment as z };