@statelyai/layout 0.1.3 → 0.3.0

package/dist/index-DNixtE3h.d.mts

@@ -0,0 +1,1318 @@
+import { r as Route } from "./types-CT2akdK0.mjs";
+import { LayoutConstraints } from "@statelyai/graph/layout";
+import { EntityRect, Graph, GraphEdge, GraphNode, GraphPatch, GraphPort, Point, VisualGraph } from "@statelyai/graph";
+
+//#region src/constraints.d.ts
+type GeometryReference = {
+  nodeId: string;
+} | {
+  edgeId: string;
+  part: "label";
+};
+type ConstraintStrength = "required" | "strong" | "medium" | "weak";
+type GeometryAttribute = "x" | "y" | "centerX" | "centerY" | "right" | "bottom";
+interface ConstraintBase {
+  id: string;
+  strength?: ConstraintStrength;
+}
+interface AlignConstraint extends ConstraintBase {
+  kind: "align";
+  entities: readonly GeometryReference[];
+  axis: "x" | "y";
+  anchor?: "start" | "center" | "end";
+}
+interface DistributeConstraint extends ConstraintBase {
+  kind: "distribute";
+  entities: readonly GeometryReference[];
+  axis: "x" | "y";
+  spacing?: "gaps" | "centers";
+  gap?: number;
+}
+interface PinConstraint extends ConstraintBase {
+  kind: "pin";
+  entity: GeometryReference;
+  x?: number;
+  y?: number;
+}
+interface LinearConstraint extends ConstraintBase {
+  kind: "linear";
+  terms: readonly {
+    entity: GeometryReference;
+    attribute: GeometryAttribute;
+    coefficient: number;
+  }[];
+  relation: "eq" | "le" | "ge";
+  value: number;
+}
+interface WaypointConstraint extends ConstraintBase {
+  kind: "waypoint";
+  edgeId: string;
+  point: {
+    x: number;
+    y: number;
+  };
+}
+type LayoutConstraint = AlignConstraint | DistributeConstraint | PinConstraint | LinearConstraint | WaypointConstraint;
+/** Serializable constraint constructors; graph geometry stays in @statelyai/graph. */
+declare const c: {
+  align: (value: Omit<AlignConstraint, "kind">) => AlignConstraint;
+  distribute: (value: Omit<DistributeConstraint, "kind">) => DistributeConstraint;
+  pin: (value: Omit<PinConstraint, "kind">) => PinConstraint;
+  linear: (value: Omit<LinearConstraint, "kind">) => LinearConstraint;
+  waypoint: (value: Omit<WaypointConstraint, "kind">) => WaypointConstraint;
+};
+//#endregion
+//#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";
+  /** Missing current geometry falls back to these matching entity IDs. */
+  previous?: VisualGraph;
+  /** Position permission only. Omitted or empty selects no nodes. */
+  nodeIds?: readonly string[];
+  /** Edge selection never grants permission to move endpoints. */
+  edgeIds?: readonly string[];
+  /** Defaults to affected; automatic changes obey edgeGeometry. */
+  routing?: "selected" | "affected";
+  /** Defaults to both; dimensions remain fixed. */
+  edgeGeometry?: "routes" | "labels" | "both";
+} | {
+  mode: "route-only";
+  previous: VisualGraph;
+  edgeIds?: readonly string[];
+};
+interface LayoutDiagnostic {
+  severity: "info" | "warning" | "error";
+  code: string;
+  message: string;
+  entityIds?: readonly string[];
+  phase?: string;
+  constraintIds?: readonly string[];
+  geometry?: "node" | "routes" | "labels";
+}
+interface LayoutPhaseMetrics {
+  id: string;
+  durationMs: number;
+}
+interface LayoutMetrics {
+  durationMs: number;
+  nodeCount: number;
+  edgeCount: number;
+  phases: readonly LayoutPhaseMetrics[];
+}
+interface LayoutCapabilities {
+  /** Common geometry constraints; absent means unsupported. */
+  constraints?: boolean;
+  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 constraints?: readonly LayoutConstraint[];
+  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;
+  constraints?: readonly LayoutConstraint[];
+  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[]>;
+  /** Reversed fixed-side routes that must stay outside the node envelope during compaction. */
+  outsideFeedbackEdgeIds?: ReadonlySet<string>;
+}
+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;
+}
+/** Geometry reserved while laying out a compound, before its ancestors. */
+interface CompoundLayoutOptions {
+  padding?: number | Partial<LayoutPadding>;
+  direction?: LayoutDirection;
+  header?: NodeSize & {
+    side?: "top" | "right" | "bottom" | "left";
+  };
+  minContentSize?: Partial<NodeSize>;
+}
+interface CompoundLayoutGeometry {
+  /** Parent-relative outer rectangle; header/content are relative to this rectangle. */
+  bounds: EntityRect;
+  header?: EntityRect;
+  content: EntityRect;
+}
+interface CompoundEdgeAttachment {
+  /** Content attachments leave toward the interior; outer attachments leave outward. */
+  source?: "content" | "outer";
+  target?: "content" | "outer";
+}
+interface LayeredLayoutOptions {
+  direction?: LayoutDirection;
+  compound?: (node: GraphNode) => CompoundLayoutOptions | undefined;
+  edgeAttachment?: (edge: GraphEdge) => CompoundEdgeAttachment | undefined;
+  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/compound.d.ts
+type CompoundVisualGraph<N = unknown, E = unknown, G = unknown, P = unknown> = VisualGraph<N, E, G, P> & {
+  /** Nodes remain parent-relative; edge rectangles and points are world-space. */
+  readonly edgeCoordinateSpace?: "world";
+  readonly compoundGeometry: ReadonlyMap<string, CompoundLayoutGeometry>;
+  /** World-space route sections preserve label gaps and fallback diagnostics. */
+  readonly compoundRoutes: ReadonlyMap<string, Route>;
+};
+//#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): CompoundVisualGraph<N, E, G, P>;
+declare const layeredAlgorithm: LayoutAlgorithm<LayeredLayoutOptions>;
+//#endregion
+export { CrossingMinimizationStrategy as $, routeEdgesOrthogonally as A, PinConstraint as At, EdgeRouter as B, breakCyclesWithModelOrderDepthFirstSearch as C, AlignConstraint as Ct, minimizeCrossingsWithModelOrder as D, GeometryReference as Dt, minimizeCrossingsWithMedian as E, GeometryAttribute as Et, CompoundEdgeAttachment as F, LayeredLayoutOptions as G, LayerAssigner as H, CompoundLayoutGeometry as I, LayeredStrategies as J, LayeredPhaseInput as K, CompoundLayoutOptions as L, routeEdgesWithSplines as M, c as Mt, CompoundVisualGraph as N, placeNodesInLayers as O, LayoutConstraint as Ot, AcyclicOrientation as P, NodeSize as Q, CrossingMinimizer as R, breakCyclesWithModelOrderBreadthFirstSearch as S, LayoutScope as St, minimizeCrossingsWithBarycenter as T, DistributeConstraint as Tt, LayerAssignment as U, EdgeRoutes as V, LayerOrder as W, NodePlacement as X, LayoutPadding as Y, NodePlacer as Z, breakCyclesByStronglyConnectedNodeType as _, LayoutExecutionContext as _t, placeNodesWithBrandesKoepf as a, fromElkLayeredOptionId as at, breakCyclesInteractively as b, LayoutRequest as bt, assignLayersWithNetworkSimplex as c, ElkLayeredOptionId as ct, assignLayersByLongestPath as d, elkLayeredOptionDefinitions as dt, CycleBreakingStrategy as et, assignLayersByLongestPathToSink as f, AnyGraph as ft, breakCyclesByStronglyConnectedConnectivity as g, LayoutDirection as gt, breakCyclesByModelOrder as h, LayoutDiagnostic as ht, placeNodesWithLinearSegments as i, NodePlacementStrategy as it, routeEdgesWithPolylines as j, WaypointConstraint as jt, placeNodesInteractively as k, LinearConstraint as kt, assignLayersByBreadthFirstModelOrder as l, ElkLayeredOptionName as lt, assignLayersWithCoffmanGraham as m, LayoutCapabilities as mt, layeredAlgorithm as n, LayeredAdvancedOptions as nt, assignLayersWithStretchWidth as o, toElkLayeredOptions as ot, assignLayersInteractively as p, LayoutAlgorithm as pt, LayeredSpacing as q, placeNodesWithNetworkSimplex as r, LayeringStrategy as rt, assignLayersWithMinWidth as s, elkLayeredEnumValues as st, getLayeredLayout as t, EdgeRoutingStyle as tt, assignLayersByDepthFirstModelOrder as u, ElkLayeredOptionValueByName as ut, breakCyclesGreedily as v, LayoutMetrics as vt, minimizeCrossingsInteractively as w, ConstraintStrength as wt, breakCyclesWithDepthFirstSearch as x, LayoutResult as xt, breakCyclesGreedilyByModelOrder as y, LayoutPhaseMetrics as yt, CycleBreaker as z };