@weasel-js/diagram 1.15.0 → 1.15.2

package/dist/index.d.ts

@@ -1,17 +1,17 @@
-import { f as Port, g as DiagramNodeLike, h as DiagramNodeReader, C as ContainerRole, i as DiagramContainer, O as Outline, a as Row, B as BodySpec, M as MeasureRowText, j as ContainerHeader, E as EdgeHop, R as RowTextStyle, k as Bounds$2, d as LayoutOptions, l as LayoutResult, G as Graph, c as LayoutFn, m as GraphSource, n as LayoutPlanner, o as LayoutDirection, L as LayoutPorts, p as LayoutPlan, q as GraphNodeLike, S as StyleField, F as FontField } from './types-B0n2CNTW.js';
-export { r as BodyDivider, s as BodyFloor, t as BodyLayout, u as BuildGraphOptions, v as BuiltinOutline, w as DEFAULT_GROUP_INSET, x as DEFAULT_HOP_SIZE, y as DEFAULT_NODE_GAP, z as DEFAULT_RANK_GAP, A as DIAGRAM_TRAIT_KEY, H as DIVIDER_HEIGHT, D as DiagramGroup, e as DiagramNode, I as DiagramNodeEntry, J as EdgeLabelRoom, K as GraphEdge, N as GraphGroup, Q as GraphNode, T as GroupInset, U as HOPS_DOC_KEY, V as HopsDocValue, W as LayoutAxes, X as OutlineDef, P as PortAnchor, Y as PortSite, b as PortSpec, Z as RowBox, _ as RowPort, $ as RowPortBox, a0 as Slot, a1 as anchorOffset, a2 as axesFor, a3 as bodyBox, a4 as bodyOutline, a5 as bodyTrait, a6 as boxForContent, a7 as buildGraph, a8 as canvasMeasure, a9 as contentBox, aa as createDiagramNodes, ab as dataKeyReader, ac as diagramContainerOf, ad as diagramNodeOf, ae as expandGroupEdges, af as graphOrder, ag as headerBox, ah as insetOf, ai as isPinned, aj as layoutBody, ak as layoutRowPorts, al as measureBody, am as outlineDetail, an as outlinePath, ao as packAcross, ap as packClusters, aq as pinnedSet, ar as planOf, as as plannerPlan, at as rankGaps, au as registerOutline, av as seededOrder, aw as settle, ax as sizeToBody, ay as titleIdOf, az as translated, aA as untilSettled } from './types-B0n2CNTW.js';
-import { P as PortsOptions, A as AvoidInput, a as AvoidRouter, b as AvoidOptions, c as AvoidRoutes, d as PlaceLabelsOptions, F as ForceOptions } from './layout.entry-CbmGuqE-.js';
-export { e as AVOID_DEFAULTS, f as AvoidEdge, g as AvoidEnd, h as AvoidLabel, i as AvoidObstacle, j as AvoidPort, k as AvoidUpdateOptions, B as BodyNodeSpec, l as BuildBodyOptions, C as COMPASS, D as DEFAULT_PORTS, m as ForceBody, n as ForceRelaxation, o as Forest, L as LabelPlacements, p as LayeredPlan, q as PORT_LABEL_GAP, r as PerimeterPortLabelBox, s as PlaceLabel, t as PlaceLabelsInput, u as PlaceRoute, v as PortLabelPlacement, R as RowNodeData, w as backEdges, x as buildBody, y as chain, z as createAvoidRouter, E as edgeHops, G as footprintNode, H as force, I as forceRelaxation, J as forestOf, K as labelCenter, M as layered, N as layeredPlan, O as marginOf, Q as outlineFromD, S as outlinePolyline, T as placeLabels, U as portLabelBox, V as portLabelsOf, W as portOf, X as portSitesOf, Y as portsOf, Z as portsOnOutline, _ as radial, $ as ranksByLength, a0 as ranksOf, a1 as rayHit, a2 as routeHolds, a3 as subtreeBlocks, a4 as tree } from './layout.entry-CbmGuqE-.js';
-import { Vec2, ActionDeps, Action, InvocationCtx, TargetPredicate, GestureBinding, Contribution, DerivedDep, Path, SceneRegistry, paintsLayer, PoseDescriptor, ChromeState, CommandFill, CommandStroke, CursorSpec, Affordance, DropVerdict, Stroke, RectPose, DepName, CarryCallbacks, Carry, Tool, AddNodeSpec, NodeId, Scene, Op, MarkerRef, LayoutStrategy, ContainerBounds, RenderLayer, TransformFollower, PoseComposition, PlacedPage, Bounds as Bounds$3, GatedLayer, NodeShapeEntry, Paint, View, SelectionApi } from '@weasel-js/core';
+import { f as Port, g as DiagramNodeLike, h as DiagramNodeReader, C as ContainerRole, i as DiagramContainer, O as Outline, a as Row, B as BodySpec, M as MeasureRowText, j as ContainerHeader, E as EdgeHop, R as RowTextStyle, k as Bounds$2, d as LayoutOptions, l as LayoutResult, G as Graph, c as LayoutFn, m as GraphSource, n as LayoutPlanner, o as LayoutDirection, L as LayoutPorts, p as LayoutPlan, q as GraphNodeLike, S as StyleField, F as FontField } from './types-D5ybp8Xh.js';
+export { r as BodyDivider, s as BodyFloor, t as BodyLayout, u as BuildGraphOptions, v as BuiltinOutline, w as DEFAULT_GROUP_INSET, x as DEFAULT_HOP_SIZE, y as DEFAULT_NODE_GAP, z as DEFAULT_RANK_GAP, A as DIAGRAM_TRAIT_KEY, H as DIVIDER_HEIGHT, D as DiagramGroup, e as DiagramNode, I as DiagramNodeEntry, J as EdgeLabelRoom, K as GraphEdge, N as GraphGroup, Q as GraphNode, T as GridOptions, U as GroupInset, V as HOPS_DOC_KEY, W as HopsDocValue, X as LayoutAxes, Y as OutlineDef, P as PortAnchor, Z as PortSite, b as PortSpec, _ as RowBox, $ as RowPort, a0 as RowPortBox, a1 as Slot, a2 as anchorOffset, a3 as axesFor, a4 as bodyBox, a5 as bodyOutline, a6 as bodyTrait, a7 as boxForContent, a8 as buildGraph, a9 as canvasMeasure, aa as contentBox, ab as createDiagramNodes, ac as dataKeyReader, ad as diagramContainerOf, ae as diagramNodeOf, af as expandGroupEdges, ag as graphOrder, ah as grid, ai as headerBox, aj as insetOf, ak as isPinned, al as layoutBody, am as layoutRowPorts, an as measureBody, ao as outlineDetail, ap as outlinePath, aq as outlineSolid, ar as packAcross, as as packClusters, at as pinnedSet, au as planOf, av as plannerPlan, aw as rankGaps, ax as registerOutline, ay as seededOrder, az as settle, aA as sizeToBody, aB as titleIdOf, aC as translated, aD as untilSettled } from './types-D5ybp8Xh.js';
+import { P as PortsOptions, A as AvoidInput, a as AvoidRouter, b as AvoidOptions, c as AvoidRoutes, d as PlaceLabelsOptions, F as ForceOptions } from './layout.entry-zstuljAl.js';
+export { e as AVOID_DEFAULTS, f as AvoidEdge, g as AvoidEnd, h as AvoidLabel, i as AvoidObstacle, j as AvoidPort, k as AvoidUpdateOptions, B as BodyNodeSpec, l as BuildBodyOptions, C as COMPASS, D as DEFAULT_PORTS, m as ForceBody, n as ForceRelaxation, o as Forest, L as LabelPlacements, p as LayeredPlan, q as PORT_LABEL_GAP, r as PerimeterPortLabelBox, s as PlaceLabel, t as PlaceLabelsInput, u as PlaceRoute, v as PortLabelPlacement, R as RowNodeData, w as backEdges, x as buildBody, y as chain, z as createAvoidRouter, E as edgeHops, G as footprintNode, H as force, I as forceRelaxation, J as forestOf, K as labelCenter, M as layered, N as layeredPlan, O as marginOf, Q as outlineFromD, S as outlinePolyline, T as placeLabels, U as portLabelBox, V as portLabelsOf, W as portOf, X as portSitesOf, Y as portsOf, Z as portsOnOutline, _ as radial, $ as ranksByLength, a0 as ranksOf, a1 as rayHit, a2 as routeHolds, a3 as subtreeBlocks, a4 as tree } from './layout.entry-zstuljAl.js';
+import { Vec2, ActionDeps, Action, InvocationCtx, TargetPredicate, GestureBinding, Contribution, DerivedDep, Path, SceneRegistry, paintsLayer, PoseDescriptor, ChromeState, CommandFill, CommandStroke, CursorSpec, Affordance, DropVerdict, Stroke, RectPose, DepName, CarryCallbacks, Carry, Tool, AddNodeSpec, NodeId, Scene, Op, MarkerRef, LayoutStrategy, ContainerBounds, RenderLayer, TransformFollower, PoseComposition, PlacedPage, Bounds as Bounds$3, GatedLayer, NodeShapeEntry, ToolsApi, Paint, View, SelectionApi, SceneCanvasTextEditor, ToolSet } from '@weasel-js/core';
 export { DropRefusal, DropVerdict } from '@weasel-js/core';
 import { Vec2 as Vec2$1, Path as Path$2 } from '@weasel-js/core/math';
 import * as react from 'react';
 import { PointerEvent as PointerEvent$1, ReactElement, ReactNode } from 'react';
-import { c as DataEdge, N as NodeStyle, a as DiagramData, b as DiagramSceneOptions, f as DiagramSpec, g as EdgeEnd, h as DiagramSceneData, i as DiagramEdge, O as OffPageSplit, D as DiagramTheme, E as EdgeStyle, j as DataContainer, d as DataNode } from './dataTypes-BIkhAOc4.js';
-export { A as ANCHOR_DERIVE_POSE, k as DEFAULT_LANE_SIZE, l as DEFAULT_NODE_STYLE, m as DEFAULT_POOL_ACROSS, n as DIAGRAM_ANCHOR, o as DIAGRAM_GROUP, p as DIAGRAM_ROLES, q as DIAGRAM_THEME_KEY, r as DataGroup, s as DataLane, t as DataMark, u as DiagramAnchor, v as DiagramDerivePose, w as DiagramFont, x as DiagramMark, y as DiagramRole, e as DiagramRouter, z as DiagramTextStyle, B as EDGE_STROKE_WIDTH, G as GROUP_DERIVE_POSE, C as GroupPoseOptions, L as LANE_STROKE_WIDTH, F as NODE_STROKE_WIDTH, H as OffPageTag, I as anchorDerivePose, J as boxAround, K as diagramAnchorOf, M as diagramEdgeOf, P as diagramGroupOf, Q as diagramMarkOf, R as groupDerivePose, S as layoutOwnsPort, T as layoutOwnsRoute, U as layoutWritesRoute, V as markShape, W as offPageTagId, X as offPageTagOf, Y as registerMarkShape, Z as rowTextStyle } from './dataTypes-BIkhAOc4.js';
+import { c as DataEdge, N as NodeStyle, a as DiagramData, b as DiagramSceneOptions, f as DiagramSpec, g as EdgeEnd, h as DiagramSceneData, i as DiagramEdge, D as DiagramTheme, O as OffPageSplit, E as EdgeStyle, j as DataContainer, d as DataNode } from './dataTypes-1ch6cMtq.js';
+export { A as ANCHOR_DERIVE_POSE, k as DEFAULT_LANE_SIZE, l as DEFAULT_NODE_STYLE, m as DEFAULT_POOL_ACROSS, n as DIAGRAM_ANCHOR, o as DIAGRAM_GROUP, p as DIAGRAM_ROLES, q as DIAGRAM_THEME_KEY, r as DataGroup, s as DataLane, t as DataMark, u as DiagramAnchor, v as DiagramDerivePose, w as DiagramFont, x as DiagramMark, y as DiagramRole, e as DiagramRouter, z as DiagramTextStyle, B as EDGE_STROKE_WIDTH, G as GROUP_DERIVE_POSE, C as GroupPoseOptions, L as LANE_STROKE_WIDTH, F as NODE_STROKE_WIDTH, H as OffPageTag, I as anchorDerivePose, J as boxAround, K as diagramAnchorOf, M as diagramEdgeOf, P as diagramGroupOf, Q as diagramMarkOf, R as groupDerivePose, S as layoutOwnsPort, T as layoutOwnsRoute, U as layoutWritesRoute, V as markShape, W as offPageTagId, X as offPageTagOf, Y as registerMarkShape, Z as rowTextStyle } from './dataTypes-1ch6cMtq.js';
 import { IconRef } from '@weasel-js/icons';
-import { D as DiagramLabel, L as LabelSpot } from './labelTrait-BBjRgxbz.js';
-export { a as LABEL_PLACEMENT, d as diagramLabelOf } from './labelTrait-BBjRgxbz.js';
+import { D as DiagramLabel, L as LabelSpot } from './labelTrait-moIciyXr.js';
+export { a as LABEL_PLACEMENT, d as diagramLabelOf } from './labelTrait-moIciyXr.js';
 import { Path as Path$1, Placement } from '@weasel-js/geom';
 import { EasingFn } from '@weasel-js/animator';
 import '@weasel-js/simulation';
@@ -659,8 +659,8 @@ interface RegionOptions<TLayer extends string> {
 }
 /** The node specs of one region, and its title unless `title` is null. */
 declare function regionSpecs<TLayer extends string>(role: ContainerRole, axis: 'x' | 'y', pose: RectPose, title: string | null, opts: RegionOptions<TLayer>): RegionSpec<TLayer>[];
-/** The lane specs a new pool at `at` starts with. */
-declare function firstLanes<TLayer extends string>(poolId: string, axis: 'x' | 'y', at: RectPose, opts: ContainerBuildOptions<TLayer>): RegionSpec<TLayer>[];
+/** The lane specs a new pool at `at` starts with: one per title in `titles`, default `Lane 1` and `Lane 2`. */
+declare function firstLanes<TLayer extends string>(poolId: string, axis: 'x' | 'y', at: RectPose, opts: ContainerBuildOptions<TLayer>, titles?: readonly string[]): RegionSpec<TLayer>[];
 
 /** A titled box, and pools of rows and of columns. */
 declare const CONTAINER_STENCILS: readonly ContainerStencil[];
@@ -685,6 +685,10 @@ interface ContainerStencil {
     };
     /** The glyph a palette draws on its button. */
     icon?: IconRef;
+    /** The title a new one is drawn with. Default `label`, and `'Pool'` for a pool. */
+    title?: string;
+    /** A new pool's lanes, by title, in the order they stack. Default two, `Lane 1` and `Lane 2`. */
+    lanes?: readonly string[];
 }
 
 type Bounds$1 = {
@@ -693,7 +697,7 @@ type Bounds$1 = {
     width: number;
     height: number;
 };
-type AnyScene$4 = Scene<unknown, string, unknown>;
+type AnyScene$7 = Scene<unknown, string, unknown>;
 /** The ops that insert `stencil` at `bounds`: the region and its title, and a
  *  pool's first lanes. Applied as one batch, they are one undo entry. */
 declare function containerBuild<TLayer extends string>(stencil: ContainerStencil, bounds: Bounds$1, opts: ContainerBuildOptions<TLayer>): {
@@ -703,19 +707,19 @@ declare function containerBuild<TLayer extends string>(stencil: ContainerStencil
 /** The axis a pool stacks its lanes along, read off its header. */
 declare const poolAxisOf: (pool: DiagramContainer) => "x" | "y";
 /** The lanes of `poolId`, in the order they stack. */
-declare function lanesOf(scene: AnyScene$4, poolId: string): NodeId[];
+declare function lanesOf(scene: AnyScene$7, poolId: string): NodeId[];
 /**
  * Add a lane to `poolId` before the lane at `index`, or at the end of the
  * stack, as one history entry. The pool grows to hold it. Returns the new
  * lane's id, or null when `poolId` is not a pool.
  */
-declare function addLane(scene: AnyScene$4, poolId: string, index?: number, style?: NodeStyle): string | null;
+declare function addLane(scene: AnyScene$7, poolId: string, index?: number, style?: NodeStyle): string | null;
 /**
  * Remove container `id` and keep its members, which take its place in its
  * parent, as one history entry. A pool's members are its lanes' members, and
  * a lane's go past its pool. Connectors on what is removed go with it.
  */
-declare function releaseMembers(scene: AnyScene$4, id: string): void;
+declare function releaseMembers(scene: AnyScene$7, id: string): void;
 
 /**
  * The commands that set the selected connectors' router: Around shapes,
@@ -769,6 +773,8 @@ interface DiagramTypeEdge {
     router?: RouterName;
     markerStart?: MarkerRef | null;
     markerEnd?: MarkerRef | null;
+    /** A dash pattern, as `Stroke.dash`: a requirement's dashed relationship. Unset, solid. */
+    dash?: readonly number[];
 }
 /** A kind of diagram: the stencil groups a new one opens with, how its connectors start out, and the
  *  layout Auto layout runs. */
@@ -781,12 +787,19 @@ interface DiagramType {
     edge?: DiagramTypeEdge;
     /** A key of `LAYOUTS`. Unset: no auto layout. */
     layout?: string;
+    /** The notations a graph page of this type is written in, as a document page's `notation` names them: the first
+     *  is the one a page authored as this type takes, and a page imported in any of them opens as this type. Unset,
+     *  a flowchart. */
+    notations?: readonly string[];
 }
 /** What {@link DIAGRAM_TYPE_DOC_KEY} holds: the diagram's type, and the groups its Shapes panel shows. */
 interface DiagramTypeDoc {
     type: string;
     groups: readonly string[];
 }
+/** The notation a flowchart's page names, where it must name one to say it is not of its chart's type: a document
+ *  page leaves `notation` unset for it. */
+declare const FLOWCHART_NOTATION = "flowchart";
 /** The document value a diagram's type and shown stencil groups are saved under. */
 declare const DIAGRAM_TYPE_DOC_KEY = "diagram:type";
 
@@ -815,6 +828,9 @@ interface DiagramStencil {
     icon?: IconRef;
     /** Laid over the style the body is drawn in: a BPMN end event's heavier ring. */
     style?: Partial<NodeStyle>;
+    /** The theme role the body is drawn in, kept on its trait as an imported shape's is: C4's `muted` for what lies
+     *  outside the system. The host resolves its colors (`StencilInsertOptions.theme`). */
+    themeRole?: string;
     /** How its body stacks its rows, as `BodySpec`'s fields of the same names. */
     padding?: number;
     gap?: number;
@@ -878,6 +894,8 @@ interface StencilInsertOptions {
         header: NodeStyle;
         bodies: readonly NodeStyle[];
     };
+    /** Resolves the role a stencil names (`DiagramStencil.themeRole`); one naming a role is drawn in `style` without it. */
+    theme?: DiagramTheme;
 }
 /**
  * Registers the `insert` dep for stencil kinds. Any other kind goes to the
@@ -1048,7 +1066,7 @@ interface LaneScratch {
 declare function laneScratchOf(hit: {
     payload?: unknown;
 } | null | undefined): LaneScratch | null;
-type AnyScene$3 = Scene<unknown, string, unknown>;
+type AnyScene$6 = Scene<unknown, string, unknown>;
 /** A pool as the affordances see it: its box, the axis it stacks along, and its lanes in order.
  *  `pose` is as stored, `at` where it draws. */
 interface PoolLanes {
@@ -1063,7 +1081,7 @@ interface PoolLanes {
     }[];
 }
 /** Every pool in `scene` that is drawn and not locked. */
-declare function poolsOf(scene: AnyScene$3): PoolLanes[];
+declare function poolsOf(scene: AnyScene$6): PoolLanes[];
 /** Options for {@link laneLayer}. */
 interface LaneLayerOptions {
     /** Screen-pixel reach of a boundary either side of it. Default 4. */
@@ -1074,9 +1092,9 @@ interface LaneLayerOptions {
     stroke?: CommandStroke;
 }
 /** The affordance: a boundary region after each lane of each pool, and an add-lane button per pool. */
-declare function createLaneAffordance(scene: AnyScene$3, opts?: LaneLayerOptions): Affordance;
+declare function createLaneAffordance(scene: AnyScene$6, opts?: LaneLayerOptions): Affordance;
 /** The composed layer, for `CanvasExtensionApi.registerLayer`. */
-declare function laneLayer(scene: AnyScene$3, opts?: LaneLayerOptions): RenderLayer<unknown>;
+declare function laneLayer(scene: AnyScene$6, opts?: LaneLayerOptions): RenderLayer<unknown>;
 
 /**
  * The container actions: dragging the boundary after a lane resizes it, the
@@ -1091,7 +1109,7 @@ declare const LANE_RESIZE_ACTION_ID = "diagram.resizeLane";
 declare const ADD_LANE_ACTION_ID = "diagram.addLane";
 /** The command that removes the selected containers and keeps their members. */
 declare const RELEASE_MEMBERS_ACTION_ID = "diagram.releaseMembers";
-type AnyScene$2 = Scene<unknown, string, unknown>;
+type AnyScene$5 = Scene<unknown, string, unknown>;
 /** A lane resized: its new size along its pool's stack. */
 interface LaneResize {
     poolId: string;
@@ -1103,10 +1121,10 @@ interface LaneResize {
 declare function commitLaneResizeToScene(resize: LaneResize, ctx: InvocationCtx): void;
 /** Where everything stands with the lane at `index` of `pool` resized to `size`: the
  *  lane, its title, the pool and its title, and every later lane with what it holds. */
-declare function laneResizeFrame(scene: AnyScene$2, pool: PoolLanes, index: number, size: number): Map<string, RectPose>;
+declare function laneResizeFrame(scene: AnyScene$5, pool: PoolLanes, index: number, size: number): Map<string, RectPose>;
 /** Options for the container actions. */
 interface LaneActionOptions extends LaneLayerOptions {
-    scene: AnyScene$2;
+    scene: AnyScene$5;
     /** The selected ids, which Release members reads. */
     selected?: () => readonly string[];
     /** Defaults to {@link commitLaneResizeToScene}. */
@@ -1790,6 +1808,10 @@ declare function labelSize(text: string, style: RowTextStyle, measure?: MeasureR
     width: number;
     height: number;
 };
+/** The id of the label at edge `edgeId`'s `from` or `to` end (`DataEdge.endLabels`). */
+declare const endLabelIdOf: (edgeId: string, end: "from" | "to") => string;
+/** Where an end label sits: just off the end, to the left of travel. `to`'s is at `'end'`. */
+declare const END_LABEL_PLACEMENT: DiagramLabel;
 /** Options for {@link edgeLabelSpec}. */
 interface EdgeLabelOptions<TLayer extends string> {
     layer: TLayer;
@@ -1801,8 +1823,11 @@ interface EdgeLabelOptions<TLayer extends string> {
     /** Sizes the box. Default: a per-character estimate. */
     measure?: MeasureRowText;
 }
-/** The label node for edge `edgeId`: a leaf that derives its pose from the edge's route. */
-declare function edgeLabelSpec<TLayer extends string>(edgeId: string, text: string, opts: EdgeLabelOptions<TLayer>): AddNodeSpec<unknown, TLayer, RectPose>;
+/** The label node for edge `edgeId`: a leaf that derives its pose from the edge's route. `id` defaults to
+ *  `<edgeId>/label`. */
+declare function edgeLabelSpec<TLayer extends string>(edgeId: string, text: string, opts: EdgeLabelOptions<TLayer> & {
+    id?: string;
+}): AddNodeSpec<unknown, TLayer, RectPose>;
 /**
  * Removes node `id` if it is an edge label left with no text, and says whether
  * it did. The default edit adds a label before its text is typed, so a host
@@ -1862,9 +1887,9 @@ interface DraggableLabel {
 }
 /** Every editable label in `scene` whose edge derives a path, in render order. */
 declare function draggableLabels(scene: Scene<unknown, string, unknown>): Iterable<DraggableLabel>;
-type AnyScene$1 = Scene<unknown, string, unknown>;
+type AnyScene$4 = Scene<unknown, string, unknown>;
 /** The topmost draggable label whose box holds `at`, as its press scratch. */
-declare function labelUnder(scene: AnyScene$1, at: Vec2$1): LabelScratch | null;
+declare function labelUnder(scene: AnyScene$4, at: Vec2$1): LabelScratch | null;
 /** The composed layer, for `CanvasExtensionApi.registerLayer`. Register it
  *  before the port layer: the last registered is hit first, and a port or a
  *  route handle must win over a label beside it. */
@@ -2188,7 +2213,8 @@ declare function subpathOf(path: Path$1, index: number): Path$1 | null;
  * so their own pose is a placeholder, and a resize handle on it sits at the
  * origin and resizes nothing. A group's box is its members' union, and a
  * pool's lane is sized by its pool's stack and resized by dragging its
- * boundary.
+ * boundary. A sequence's part is drawn from its root's data, and a selected
+ * one is there to be deleted, not resized.
  */
 declare function diagramResizable(scene: {
     get(id: never): {
@@ -2681,6 +2707,175 @@ declare function diagramLayoutOf(specs: readonly DiagramSpec[]): {
     containers: ContainerEdit[];
 };
 
+/**
+ * A sequence diagram as plain data: participants left to right, and the steps
+ * between them top to bottom, one row each.
+ */
+
+/** One column: a head drawn at the top, and the lifeline under it. */
+interface SeqParticipant {
+    /** Messages, notes, and boxes name it by this. */
+    id: string;
+    /** What its head says. Default its id. */
+    label?: string;
+    /** Default `'rect'`. `actor`, `boundary`, `control`, `entity`, `cylinder`, `collections`, and `queue` are the UML figures. */
+    outline?: Outline;
+    /** The theme role its head is drawn in. */
+    style?: string;
+    /** Colors of its own, over its role's. */
+    colors?: Partial<NodeStyle>;
+}
+/** A message from one lifeline to another, or to itself. */
+interface SeqMessage {
+    kind: 'message';
+    id: string;
+    from: string;
+    to: string;
+    text?: string;
+    line: 'solid' | 'dashed';
+    head: 'arrow' | 'open' | 'cross' | 'none';
+    /** An arrowhead at the `from` end too. */
+    both?: boolean;
+    /** Sent without waiting for an answer. */
+    async?: boolean;
+    /** Starts an activation on that end, at this message. */
+    activate?: 'to' | 'from';
+    /** Ends the innermost activation on that end, at this message. */
+    deactivate?: 'to' | 'from';
+}
+/** A note beside one lifeline, or over one or more. */
+interface SeqNote {
+    kind: 'note';
+    id: string;
+    /** Participant ids. Over two, it spans from the first to the last. */
+    over: readonly string[];
+    /** Beside its participant rather than over it. */
+    side?: 'left' | 'right';
+    text: string;
+}
+/** A lifeline's activation starting or ending, its head created, or its lifeline ended. */
+interface SeqMark {
+    kind: 'activate' | 'deactivate' | 'create' | 'destroy';
+    participant: string;
+}
+/** A run of steps boxed together: a loop, the branches of an alt, the threads of a par. */
+interface SeqFragment {
+    kind: 'fragment';
+    id: string;
+    /** `region` is a plain colored box, with no type tab. */
+    type: 'loop' | 'alt' | 'opt' | 'par' | 'critical' | 'break' | 'region';
+    /** One for most types; an `alt`'s branches, a `par`'s threads, a `critical`'s options each start another. */
+    sections: readonly SeqSection[];
+    colors?: Partial<NodeStyle>;
+}
+/** One section of a fragment: its guard or title, and its steps. */
+interface SeqSection {
+    label?: string;
+    steps: readonly SeqStep[];
+}
+/** One row of a sequence, or a fragment holding a run of rows. */
+type SeqStep = SeqMessage | SeqNote | SeqMark | SeqFragment;
+/** A box drawn around some participants' columns. */
+interface SeqBox {
+    id: string;
+    label?: string;
+    /** Participant ids. */
+    members: readonly string[];
+    colors?: Partial<NodeStyle>;
+}
+/** A sequence diagram, the data `sequenceSpecs` draws. */
+interface SequenceData {
+    participants: readonly SeqParticipant[];
+    /** Top to bottom, one row each; a fragment holds a run. */
+    steps: readonly SeqStep[];
+    boxes?: readonly SeqBox[];
+    /** Messages are numbered from this one. Unset, they are not numbered. */
+    autonumber?: number;
+}
+/** A step with an id of its own: a message, a note, or a fragment. */
+type SeqIdStep = SeqMessage | SeqNote | SeqFragment;
+/** Where a step stands: the list it is in (`null` the top level, else a fragment's section), and its place in it. */
+interface StepPlace {
+    parent: {
+        fragment: string;
+        section: number;
+    } | null;
+    index: number;
+}
+/** A run of text in a sequence an edit can set: a head's, a message's or note's, a fragment section's label, or a box's. */
+type SeqTextTarget = {
+    participant: string;
+} | {
+    step: string;
+} | {
+    fragment: string;
+    section: number;
+} | {
+    box: string;
+};
+/**
+ * What starts or ends an activation, or ends a lifeline: a mark step, by where
+ * it stands, or a message's `activate` or `deactivate` flag.
+ */
+type SeqMarkRef = {
+    place: StepPlace;
+} | {
+    message: string;
+    flag: 'activate' | 'deactivate';
+};
+
+/**
+ * Writing a sequence edit into a scene: the root's data replaced and its parts
+ * built again, as one undo entry.
+ */
+
+type AnyScene$3 = Scene<unknown, string, unknown>;
+/** How a scene's sequences are drawn when an edit builds their parts again. */
+interface SequenceDrawOptions {
+    /** Measures text. Default an estimate from character count; pass what the sequence was first drawn with. */
+    measure?: MeasureRowText;
+    /** Default the scene's own `diagram:theme`. */
+    theme?: DiagramTheme;
+}
+/** Replaces root `id`'s sequence with `data` and builds its parts again, as one undo entry under `label`. */
+declare function commitSequence(scene: AnyScene$3, id: string, data: SequenceData, label: string, opts?: SequenceDrawOptions): void;
+/**
+ * Adds a new sequence root drawing `data` with its top-left corner at `at`,
+ * as one undo entry under `label`, and returns its id. On `layer`, default
+ * the scene's first.
+ */
+declare function startSequence(scene: AnyScene$3, at: {
+    x: number;
+    y: number;
+}, data: SequenceData, label: string, opts?: SequenceDrawOptions & {
+    layer?: string;
+}): string;
+/** Builds every sequence in `scene` again from its own data, in the batch the caller has open: after a theme change. */
+declare function redrawSequences(scene: AnyScene$3, opts?: SequenceDrawOptions): void;
+/** A sequence edit: root `id`'s new data. */
+interface SequenceEdit {
+    id: string;
+    data: SequenceData;
+    /** What undo calls it. */
+    label: string;
+}
+/**
+ * Folds a text edit that has just been written to one of a sequence's text
+ * parts into its root's data: the edit is undone and `commit` gets the
+ * sequence with the new text, so the change is one entry on the data, not a
+ * part that the next build would overwrite. Does nothing for any other node,
+ * or text that did not change.
+ */
+declare function foldSequenceText(scene: AnyScene$3, textId: string, commit: (edit: SequenceEdit) => void): void;
+/** Options for a sequence's editing actions: how an edit is committed and drawn. */
+interface SequenceEditOptions extends SequenceDrawOptions {
+    /** Defaults to {@link commitSequence} against `deps.scene`, with the draw options. */
+    commit?: (edit: SequenceEdit, ctx: Pick<InvocationCtx, 'deps'>) => void;
+    id?: string;
+}
+/** `opts.commit`, or {@link commitSequence} against the scene the edit's deps hold, drawn with `opts`. */
+declare function sequenceCommitOf(opts: SequenceEditOptions): (edit: SequenceEdit, ctx: Pick<InvocationCtx, 'deps'>) => void;
+
 /** One end of a data edge moved onto node `node`, at `port` or on its body. */
 interface ReconnectChange {
     /** The data edge's id, `edgeIdOf` of it. */
@@ -2805,6 +3000,11 @@ interface DiagramViewProps {
     onReorder?: (change: ReorderChange) => void;
     /** Set to report a double-click on an edge, for its label to be edited. */
     onEditLabel?: (edge: string) => void;
+    /** Set to edit the sequences `sequenceSpecs` drew: drag a message, note, or fragment to another row, a head
+     *  to another column, a message end to another lifeline, double-click text to edit it in place, click a part
+     *  to select it, and press Delete to remove it. Reports each edit as the sequence's new data and draws
+     *  nothing: rebuild its specs from it. `useSequenceTools`, passed as `tools`, adds to a sequence. */
+    onEditSequence?: (edit: SequenceEdit) => void;
     /** Set to let an edge's label be dragged along and beside it, and to enable
      *  Reset label for the selected edge. Reports the placement and draws
      *  nothing; store it as the data edge's `labelPlacement`, and delete that
@@ -2823,6 +3023,10 @@ interface DiagramViewProps {
     connectBodies?: boolean;
     /** Contributions to install after the view's own: a tool's bindings, a key. */
     ambient?: readonly Contribution[];
+    /** Tools the user can pick beside select, keyed by id, as `<SceneCanvas tools>` takes them: `useSequenceTools`'s, say. */
+    tools?: Record<string, Tool>;
+    /** Called with the canvas's tools, for a palette to pick them from. */
+    onToolsCreated?: (tools: ToolsApi) => void;
     /** Whether ports are drawn. `'connect'` draws them and lets one be dragged
      *  onto another; `'show'` only draws them. Default: `'connect'` when
      *  `onConnect` is set, else `'none'`. */
@@ -3066,7 +3270,7 @@ declare function relayoutBodies(scene: RelayoutScene, ids: Iterable<string>, mea
  * naming a shape's or connector's role, and setting a color by hand.
  */
 
-type AnyScene = Scene<unknown, string, unknown>;
+type AnyScene$2 = Scene<unknown, string, unknown>;
 /** What a styleable node says about its style: a shape or a connector, the role it names, and the
  *  colors its author set by hand. */
 interface DiagramStyleState {
@@ -3094,7 +3298,7 @@ interface ApplyDiagramThemeOptions {
 }
 /** Recolors the whole scene in `theme` and saves it as the `diagram:theme` document value, as one
  *  undo entry. Colors the author set by hand stay. */
-declare function applyDiagramTheme(scene: AnyScene, theme: DiagramTheme, label?: string, opts?: ApplyDiagramThemeOptions): void;
+declare function applyDiagramTheme(scene: AnyScene$2, theme: DiagramTheme, label?: string, opts?: ApplyDiagramThemeOptions): void;
 /** Options for {@link setDiagramStyle} and {@link setDiagramColor}. */
 interface DiagramStyleEditOptions {
     /** The theme to color by. Default the scene's own `diagram:theme`. */
@@ -3106,20 +3310,20 @@ interface DiagramStyleEditOptions {
  * it, as one undo entry. Choosing a role hands back any color the author had
  * set, so the role shows.
  */
-declare function setDiagramStyle(scene: AnyScene, ids: readonly string[], role: string, opts?: DiagramStyleEditOptions): void;
+declare function setDiagramStyle(scene: AnyScene$2, ids: readonly string[], role: string, opts?: DiagramStyleEditOptions): void;
 /**
  * Sets `field` to `color` on every shape and connector among `ids` — `text`
  * reaching a shape's rows and a connector's label — and records it in their
  * `ownStyle`, so a theme change leaves it. One undo entry. A connector has no
  * fill, and ignores one.
  */
-declare function setDiagramColor(scene: AnyScene, ids: readonly string[], field: StyleField, color: string, opts?: Pick<DiagramStyleEditOptions, 'label'>): void;
+declare function setDiagramColor(scene: AnyScene$2, ids: readonly string[], field: StyleField, color: string, opts?: Pick<DiagramStyleEditOptions, 'label'>): void;
 /**
  * Sets the text of every shape and connector among `ids` — a shape's rows, a
  * connector's label — to `size`, and records it in their `ownFont`, so a
  * theme's size change leaves it. One undo entry.
  */
-declare function setDiagramFontSize(scene: AnyScene, ids: readonly string[], size: number, opts?: Pick<DiagramStyleEditOptions, 'label'> & {
+declare function setDiagramFontSize(scene: AnyScene$2, ids: readonly string[], size: number, opts?: Pick<DiagramStyleEditOptions, 'label'> & {
     measure?: MeasureRowText;
 }): void;
 
@@ -3181,6 +3385,18 @@ declare const MIND_MAP_TYPE: DiagramType;
 declare const UML_CLASS_TYPE: DiagramType;
 /** An entity-relationship diagram: connectors routed orthogonally, one at the start and many at the end. */
 declare const ERD_TYPE: DiagramType;
+/** A state machine: states and pseudostates, composites holding more, transitions ending in an arrow. */
+declare const STATE_TYPE: DiagramType;
+/** A requirement diagram: requirements and the elements meeting them, joined by dashed relationships. */
+declare const REQUIREMENT_TYPE: DiagramType;
+/** A C4 model, at any of its levels: a page authored as one is a context diagram. */
+declare const C4_TYPE: DiagramType;
+/** A block diagram: the flowchart's shapes, laid out on a grid. */
+declare const BLOCK_TYPE: DiagramType;
+/** An architecture diagram: services in groups, joined square at their sides with plain links. */
+declare const ARCHITECTURE_TYPE: DiagramType;
+/** A kanban board: a pool of column lanes, cards stacked down them, and no connectors. */
+declare const KANBAN_TYPE: DiagramType;
 /** The diagram types this package ships, by id, in menu order. */
 declare const DIAGRAM_TYPES: Readonly<Record<string, DiagramType>>;
 /** Whether `stencil` is a container's rather than a shape's. */
@@ -3190,7 +3406,13 @@ declare function groupStencils(ids: readonly string[], catalog?: Readonly<Record
 /** The ids of `group`'s stencils. */
 declare const groupStencilIds: (group: StencilGroup) => string[];
 
-/** A scene as the type reader and writers use it. */
+/** A scene as the type readers use it. */
+interface DiagramTypeReadable {
+    doc: {
+        get(key: string): unknown;
+    };
+}
+/** A scene as the type writers use it. */
 interface DiagramTypeScene {
     doc: {
         get(key: string): unknown;
@@ -3209,9 +3431,13 @@ interface DiagramTypeWriteOptions {
 declare function diagramTypeDocValue(id: string, types?: Types): DiagramTypeDoc;
 /** The type and shown groups a scene holds. A scene holding none, or naming a type `types` lacks,
  *  reads as flowchart with its groups. */
-declare function diagramTypeDocOf(scene: Pick<DiagramTypeScene, 'doc'>, types?: Types): DiagramTypeDoc;
+declare function diagramTypeDocOf(scene: DiagramTypeReadable, types?: Types): DiagramTypeDoc;
 /** The type a scene holds, as {@link diagramTypeDocOf} reads it. */
-declare function diagramTypeOf(scene: Pick<DiagramTypeScene, 'doc'>, types?: Types): DiagramType;
+declare function diagramTypeOf(scene: DiagramTypeReadable, types?: Types): DiagramType;
+/** The notation a graph page of the scene's type is written in. */
+declare const diagramNotationOf: (scene: DiagramTypeReadable, types?: Types) => string;
+/** The type whose pages `notation` writes, unset read as a flowchart's; `null` when no type in `types` claims it. */
+declare function diagramTypeOfNotation(notation: string | undefined, types?: Types): DiagramType | null;
 /** Makes the scene type `id`, its shown groups replaced by the type's. */
 declare function setDiagramType(scene: DiagramTypeScene, id: string, opts?: DiagramTypeWriteOptions): void;
 /** Shows stencil group `id` after the ones shown. Nothing when it is shown already. */
@@ -3220,7 +3446,7 @@ declare function addStencilGroup(scene: DiagramTypeScene, id: string, opts?: Dia
 declare function removeStencilGroup(scene: DiagramTypeScene, id: string, opts?: DiagramTypeWriteOptions): void;
 
 /** The stroke a new connector in a diagram of `type` starts with: the theme's, with each end marker
- *  the type sets put over it. A marker set to `null` draws no marker on that end. */
+ *  the type sets put over it, and its dash. A marker set to `null` draws no marker on that end. */
 declare function diagramTypeEdgeStroke(theme: DiagramTheme, type: DiagramType): Stroke;
 
 /** Network devices, each labeled under its drawing. A database and a cloud wear the general figures, with their labels inside. */
@@ -3267,4 +3493,673 @@ declare const ERD_STENCILS: readonly DiagramStencil[];
 /** The ERD symbols as a stencil group. */
 declare const ERD_GROUP: StencilGroup;
 
-export { ADD_LANE_ACTION_ID, type ApplyDiagramThemeOptions, type ApplyLayoutOptions, AvoidInput, AvoidOptions, AvoidRouter, AvoidRoutes, type AvoidRouting, type AvoidRoutingOptions, type AvoidSceneOptions, BPMN_GROUP, BPMN_STENCILS, BPMN_TYPE, type BodyEnd, type BodyHit, BodySpec, Bounds$2 as Bounds, CONNECTOR_ACTION_ID, CONNECTOR_TOOL_ID, CONNECT_ACTION_ID, CONTAINERS_GROUP, CONTAINER_HEADER, CONTAINER_LAYOUTS, CONTAINER_STENCILS, type CanConnect, type CanDropItem, type CanReparent, type ConnectActionOptions, type ConnectEnd, type ConnectView, type ContainerBuildOptions, type ContainerEdit, ContainerHeader, type ContainerLayoutOptions, ContainerRole, type ContainerStencil, DEFAULT_EDGE_STROKE, DEFAULT_EDGE_STYLE, DEFAULT_GROUP_STYLE, DIAGRAM_CONTAINER_LAYOUT, DIAGRAM_EDGE, DIAGRAM_ITEM_CARRY, DIAGRAM_LABEL, DIAGRAM_LANE_COLUMNS_LAYOUT, DIAGRAM_LANE_ROWS_LAYOUT, DIAGRAM_OFF_PAGE_TAG, DIAGRAM_PASS_ORDER, DIAGRAM_POOL_COLUMNS_LAYOUT, DIAGRAM_POOL_ROWS_LAYOUT, DIAGRAM_THEMES, DIAGRAM_THEME_EXTENSION, DIAGRAM_TYPES, DIAGRAM_TYPE_DOC_KEY, DataContainer, DataEdge, DataNode, type DeleteReport, DiagramContainer, type DiagramContributionOptions, DiagramData, DiagramEdge, DiagramLabel, type DiagramLayout, DiagramNodeLike, DiagramNodeReader, type DiagramOverlay, DiagramSceneData, DiagramSceneOptions, type DiagramShapeOptions, DiagramSpec, type DiagramStencil, type DiagramStyleEditOptions, type DiagramStyleState, DiagramTheme, type DiagramType, type DiagramTypeDoc, type DiagramTypeEdge, type DiagramTypeScene, type DiagramTypeWriteOptions, DiagramView, type DiagramViewApi, type DiagramViewProps, type DraggableLabel, type DropParentScene, EASED_LAYOUTS, EDGE_DERIVE_PATH, EDGE_END_AFFORDANCE_KIND, EDGE_END_LAYER_ID, EDIT_CONTAINER_TITLE_ACTION_ID, EDIT_EDGE_LABEL_ACTION_ID, ERD_GROUP, ERD_STENCILS, ERD_TYPE, type EasedProducerOptions, EdgeEnd, type EdgeEndAffordanceOptions, type EdgeEndScratch, EdgeHop, type EdgeLabelOptions, type EdgeRoute, type EdgeRouteOptions, type EdgeRouteState, EdgeStyle, type EditEdgeLabelOptions, type EndChange, FLOWCHART_GROUP, FLOWCHART_STENCILS, FLOWCHART_TYPE, FOLLOW_OFF_PAGE_ACTION_ID, type FollowOffPageOptions, FontField, ForceOptions, type ForceProducerOptions, GRAB_EDGE_END_ACTION_ID, GRAB_LABEL_ACTION_ID, GRAB_PORT_ACTION_ID, GRAB_WAYPOINT_ACTION_ID, Graph, GraphNodeLike, GraphSource, type Hops, type HopsOptions, ITEM_DROP_ACTION_ID, type ItemDrop, type ItemDropOptions, type ItemDropTarget, LABEL_DERIVE_POSE, LABEL_DRAG_AFFORDANCE_KIND, LABEL_DRAG_LAYER_ID, LANE_AFFORDANCE_KIND, LANE_HEADER_SIZE, LANE_LAYER_ID, LANE_RESIZE_ACTION_ID, LAYOUTS, LAYOUT_ACTION_ID, type LabelDragOptions, type LabelEdit, type LabelMove, type LabelPlacement, type LabelPlacementOptions, type LabelPoseOptions, type LabelScratch, LabelSpot, type LaneActionOptions, type LaneLayerOptions, type LaneResize, type LaneScratch, type LaneStackOptions, type LayeredRoute, type LayeredRouteInput, type LayoutActionOptions, type LayoutDiagramOptions, LayoutDirection, LayoutFn, LayoutOptions, LayoutPlan, LayoutPlanner, LayoutPorts, LayoutResult, type LayoutRoutes, type LiveLayout, type LiveLayoutCtx, type LiveLayoutFrame, type LiveLayoutProducer, MIND_MAP_GROUP, MIND_MAP_STENCILS, MIND_MAP_TYPE, MIN_LANE_SIZE, MOVE_LABEL_ACTION_ID, MeasureRowText, type MovingEnd, NETWORK_GROUP, NETWORK_STENCILS, NETWORK_TYPE, type NodeMove, type NodeResize, NodeStyle, OFF_PAGE_STUB, OFF_PAGE_TAG_DERIVE_POSE, OFF_PAGE_TAG_PADDING, ORG_CHART_TYPE, ORG_GROUP, ORG_STENCILS, type OffPageEdgeInput, type OffPageMarkerOptions, OffPageSplit, type OffPageSplitInput, type OffPageTagLook, type OffPageTarget, Outline, POOL_HEADER_SIZE, PORT_AFFORDANCE_KIND, PORT_LAYER_ID, type ParticipantPose, type ParticipantScene, type ParticipantSource, type PendingEdge, PlaceLabelsOptions, type PoolLanes, Port, type PortAffordanceOptions, type PortScratch, PortsOptions, RECONNECT_ACTION_ID, RELEASE_MEMBERS_ACTION_ID, REMOVE_WAYPOINT_ACTION_ID, REORDER_ACTION_ID, RESET_LABEL_ACTION_ID, RESET_ROUTE_ACTION_ID, ROUTERS, ROUTER_LABELS, ROUTE_EDIT_ACTION_ID, type ReconnectChange, type ReconnectOptions, type RegionOptions, type RegionSpec, type RelayoutScene, type ReorderChange, type ReorderGap, type ReorderItem, type ReorderMove, type ReorderOptions, type ReorderSlots, type ResolvedRoute, type RouteChange, type RouteEdge, type RouteEdit, type RouteEditOptions, type RouteHandle, type RouteRequest, type RoutedScene, type Router, type RouterEdit, type RouterName, Row, RowTextStyle, SELECT_LABEL_EDGE_ACTION_ID, SET_HOPS_ACTION_ID, SET_ROUTER_ACTION_IDS, STENCIL_GROUPS, STEP_REORDER_ACTION_ID, type SelfLoop, type SetHopsOptions, type SetRouterOptions, type SpecRouterOptions, StencilGhost, type StencilGhostProps, type StencilGroup, type StencilInsertOptions, StyleField, type StyledRegion, type ThemePath, type ThemedNode, type ThemedScene, UML_CLASS_TYPE, UML_GROUP, UML_STENCILS, type UseLiveLayoutOptions, WAYPOINT_AFFORDANCE_KIND, WAYPOINT_HIT_PX, WAYPOINT_LAYER_ID, type WaypointAffordanceOptions, type WaypointScratch, addLane, addStencilGroup, addThemeRole, applyDiagramTheme, applyLayout, avoid, avoidSceneInput, bezier, bodyAt, bodyFollower, commitEdgeToScene, commitLabelToScene, commitLaneResizeToScene, commitReconnectToScene, commitRouteToScene, commitRouterToScene, connectBinding, connectorTool, containerBuild, containerShape, createAddLaneAction, createConnectAction, createDiagramContribution, createEdgeEndAffordance, createFollowOffPageAction, createItemDropAction, createLabelDragAction, createLaneAffordance, createLaneResizeAction, createLayoutAction, createPortAffordance, createReconnectAction, createReleaseMembersAction, createRemoveWaypointAction, createReorderAction, createResetLabelAction, createResetRouteAction, createRouteEditAction, createSetHopsAction, createSetRouterAction, createSpecHops, createSpecLabelPlacer, createSpecRouter, createStepReorderAction, createWaypointAffordance, dataEdgeStyle, dataNodeStyle, dataOffPage, dataRegionStyle, defaultCanConnect, diagramCanDropInto, diagramContainerLayout, diagramContainers, diagramDropParentAt, diagramEdgeEnds, diagramLabelDrag, diagramLayoutOf, diagramOffPage, diagramPages, diagramPorts, diagramResizable, diagramScene, diagramShape, diagramStyleOf, diagramThemeFrom, diagramThemeFromTokens, diagramThemeOf, diagramTypeDocOf, diagramTypeDocValue, diagramTypeEdgeStroke, diagramTypeOf, diagramWaypoints, documentBoundsOf, dragItemProps, dragSegment, dragVertex, draggableLabels, dropEmptyEdgeLabel, easedProducer, edgeDerivePath, edgeEndLayer, edgeEndScratchOf, edgeIdOf, edgeLabelSpec, edgeRouter, editContainerTitleAction, editContainerTitleBinding, editEdgeLabelAction, editEdgeLabelBinding, editableTheme, firstLanes, followOffPageBinding, forceProducer, forkTheme, grabPortAction, grabPortBindings, groupReorderContribution, groupReorderSlots, groupStencilIds, groupStencils, headerIdOf, hopFollower, insertWaypoint, installAvoidRouting, installHops, installLabelPlacement, installOffPageMarkers, isBodyEnd, isBodyOrRegion, isContainerStencil, isDiagramBody, isShippedTheme, itemDropContribution, labelDerivePose, labelDragLayer, labelScratchOf, labelSize, labelUnder, laneHeader, laneLayer, laneResizeFrame, laneScratchOf, laneStackLayout, lanesOf, layeredRoutes, layoutDiagram, layoutPoses, movedLabelData, nextOffPageRef, offPageFarText, offPageOps, offPageSplits, offPageTagData, offPageTagDerivePose, offPageTagLook, offPageTagSize, offPageTagSpec, offPageTagSpecs, offPageTagText, offPageTargetOf, orthogonal, parseDiagramTheme, pinSegment, poolAxisOf, poolHeader, poolsOf, portLayer, portScratchOf, reconnectBinding, regionHeaderAt, regionSpecs, registerDiagramShape, relayoutBodies, releaseMembers, removeSegment, removeStencilGroup, removeThemeRole, removeWaypoint, renameThemeRole, rendererMeasure, reorderBinding, reorderContribution, resolveEnd, roleEdgeStyle, roleStyle, routeDataOps, routeHandles, routeStateOf, routeWrites, routedData, routerActions, routesOf, sceneParticipants, segmentAxis, selfLoop, sequenceSlots, setDiagramColor, setDiagramFontSize, setDiagramStyle, setDiagramType, setThemeValue, simplifyStops, stackedLanes, startItemDrag, stencilBuild, stencilIdOf, stencilKind, stencilTool, straight, subpathOf, themeDocValue, themeEdgeStroke, themeFont, themeLabelFont, themeLabelStyle, themeRoles, themeToJson, themeValue, themeWrites, titlePose, unpinSegment, useAvoidRouting, useConnectorTool, useHops, useLabelPlacement, useLiveLayout, useMirroredSelection, useOffPageMarkers, useStencilInsert, useStencilTool, waypointFollower, waypointLayer, waypointScratchOf, withDiagramRegistry, withHops, withRouter };
+/** A state machine's states and pseudostates, notes, and composite states. */
+declare const STATE_STENCILS: readonly (DiagramStencil | ContainerStencil)[];
+/** The state machine symbols as a stencil group. */
+declare const STATE_GROUP: StencilGroup;
+
+/** A requirement diagram's requirements and the elements that satisfy them. */
+declare const REQUIREMENT_STENCILS: readonly DiagramStencil[];
+/** The requirement diagram symbols as a stencil group. */
+declare const REQUIREMENT_GROUP: StencilGroup;
+
+/** C4's people, systems, containers, and components, each a store or a queue where C4 has one, and the
+ *  boundaries around them. */
+declare const C4_STENCILS: readonly (DiagramStencil | ContainerStencil)[];
+/** The C4 symbols as a stencil group. */
+declare const C4_GROUP: StencilGroup;
+
+/** An architecture diagram's services, by the icons Mermaid builds in, a junction to join edges at, and a group. */
+declare const ARCHITECTURE_STENCILS: readonly (DiagramStencil | ContainerStencil)[];
+/** The architecture symbols as a stencil group. */
+declare const ARCHITECTURE_GROUP: StencilGroup;
+
+/** A kanban board: a pool whose lanes are its columns, and cards to stack down them, each with a `field` row of
+ *  metadata. */
+declare const KANBAN_STENCILS: readonly (DiagramStencil | ContainerStencil)[];
+/** The kanban symbols as a stencil group. */
+declare const KANBAN_GROUP: StencilGroup;
+
+/**
+ * The edits a sequence takes, each a pure function from one `SequenceData` to
+ * the next. A no-op returns the data it was given, so a caller can tell
+ * nothing changed by identity.
+ */
+
+type Steps = readonly SeqStep[];
+/** The step list `parent` names: the top level, or one section of a fragment anywhere in `steps`. `null` when there is none. */
+declare function stepListOf(steps: Steps, parent: StepPlace['parent']): Steps | null;
+/** The step with `id`, at any depth. */
+declare function findStep(steps: Steps, id: string): SeqStep | null;
+/** Where the step with `id` stands. */
+declare function placeOf(steps: Steps, id: string, parent?: StepPlace['parent']): StepPlace | null;
+/**
+ * The step `id` moved to `to`, whose `index` counts the list as it stands
+ * before the move. A fragment cannot move into itself.
+ */
+declare function moveStep(data: SequenceData, id: string, to: StepPlace): SequenceData;
+/** Participant `id` moved to `index` among them, counted as they stand before the move. */
+declare function moveParticipant(data: SequenceData, id: string, index: number): SequenceData;
+/** Message `id`'s `end` moved to `participant`'s lifeline. */
+declare function reconnectMessage(data: SequenceData, id: string, end: 'from' | 'to', participant: string): SequenceData;
+/** `data` with `target`'s text set to `text`. Empty text clears a label; a note keeps its text as given. */
+declare function setSequenceText(data: SequenceData, target: SeqTextTarget, text: string): SequenceData;
+/** The text `target` holds in `data`, as an edit opens on it. */
+declare function sequenceTextOf(data: SequenceData, target: SeqTextTarget): string | null;
+
+/**
+ * Authoring a sequence's columns: participants added and removed, boxes drawn
+ * around them, messages numbered. Pure functions from one `SequenceData` to
+ * the next; a no-op returns the data it was given.
+ */
+
+/** Whether a participant, step, or box in `data` already has `id`. */
+declare const seqIdTaken: (data: SequenceData, id: string) => boolean;
+/** An id nothing in `data` uses yet: `prefix` and the lowest free number from 1. */
+declare function freshSeqId(data: SequenceData, prefix: string): string;
+/** What a new participant is drawn as: a plain box, or the UML stick figure. */
+type SeqParticipantKind = 'participant' | 'actor';
+/** A participant `data` can take: a fresh id, and a label naming its kind and number ("Actor 2"). */
+declare function newParticipant(data: SequenceData, kind?: SeqParticipantKind): SeqParticipant;
+/** `p` added at `index` among the participants (default last). Nothing changes when its id is taken. */
+declare function addParticipant(data: SequenceData, p: SeqParticipant, index?: number): SequenceData;
+/**
+ * Participant `id` removed, with what names it: every message to or from it,
+ * every activation, creation, or destruction of it, and it from every note
+ * and box, a note or box left naming no one going too. Fragments stay, even
+ * emptied, since they hold no participant of their own.
+ */
+declare function removeParticipant(data: SequenceData, id: string): SequenceData;
+/** Participant `id` drawn as `outline`; `undefined` or `'rect'` is the plain box. */
+declare function setParticipantOutline(data: SequenceData, id: string, outline: Outline | undefined): SequenceData;
+/**
+ * `box` drawn around its members: ids naming no participant are dropped, each
+ * member leaves any box it was in (one left empty goes), and the members are
+ * gathered side by side where the first of them stands, since a box spans
+ * every column between its ends. Nothing changes for a box naming no one, or
+ * whose id is taken.
+ */
+declare function addBox(data: SequenceData, box: SeqBox): SequenceData;
+/** Box `id` removed; its members stay. */
+declare function removeBox(data: SequenceData, id: string): SequenceData;
+/** Messages numbered from `from`, or not numbered at all for `undefined`. */
+declare function setAutonumber(data: SequenceData, from: number | undefined): SequenceData;
+
+/** How a message is drawn: its line, its head, and whether it has a head at both ends or is sent without waiting. */
+type SeqArrow = Pick<SeqMessage, 'line' | 'head'> & Pick<Partial<SeqMessage>, 'both' | 'async'>;
+/** The arrows a message is commonly drawn with, by name; each one Mermaid writes. */
+declare const SEQ_ARROWS: {
+    /** A call: a solid line, a filled head. */
+    readonly sync: {
+        readonly line: "solid";
+        readonly head: "arrow";
+    };
+    /** An answer: a dashed line, a filled head. */
+    readonly reply: {
+        readonly line: "dashed";
+        readonly head: "arrow";
+    };
+    /** Sent without waiting: a solid line, an open head. */
+    readonly async: {
+        readonly line: "solid";
+        readonly head: "open";
+        readonly async: true;
+    };
+    /** Lost or refused: a solid line ending in a cross. */
+    readonly lost: {
+        readonly line: "solid";
+        readonly head: "cross";
+    };
+    /** A plain solid line. */
+    readonly line: {
+        readonly line: "solid";
+        readonly head: "none";
+    };
+    /** A plain dashed line. */
+    readonly dashed: {
+        readonly line: "dashed";
+        readonly head: "none";
+    };
+    /** Both ways: a solid line, filled heads at both ends. */
+    readonly both: {
+        readonly line: "solid";
+        readonly head: "arrow";
+        readonly both: true;
+    };
+};
+/** A name in {@link SEQ_ARROWS}. */
+type SeqArrowName = keyof typeof SEQ_ARROWS;
+/** The fragment types that hold more than one section: an alt's branches, a par's threads, a critical's options. */
+declare const SEQ_MULTI_SECTION: ReadonlySet<SeqFragment['type']>;
+/** `step` inserted at `at`, whose index is clamped to its list. Nothing changes where `at` names no list, or the step's id is taken. */
+declare function insertStep(data: SequenceData, step: SeqStep, at: StepPlace): SequenceData;
+/** What {@link insertMessage} takes. */
+interface NewSeqMessage {
+    from: string;
+    to: string;
+    at: StepPlace;
+    /** A name in {@link SEQ_ARROWS}, or an arrow of its own. Default `'sync'`. */
+    arrow?: SeqArrowName | SeqArrow;
+    text?: string;
+    /** Default a fresh `m` id. */
+    id?: string;
+}
+/** A message from `from` to `to` (the same for a self-message) inserted at `at`. Nothing changes for an unknown participant. */
+declare function insertMessage(data: SequenceData, m: NewSeqMessage): SequenceData;
+/** What {@link insertNote} takes. */
+interface NewSeqNote {
+    /** Participant ids: one, or the first and last of a span. */
+    over: readonly string[];
+    /** Beside its participant rather than over it. */
+    side?: 'left' | 'right';
+    at: StepPlace;
+    /** Default `'Note'`. */
+    text?: string;
+    /** Default a fresh `n` id. */
+    id?: string;
+}
+/** A note over (or beside) participants inserted at `at`. Nothing changes for an unknown participant or none at all. */
+declare function insertNote(data: SequenceData, n: NewSeqNote): SequenceData;
+/**
+ * A lifeline mark inserted at `at`: an activation starting or ending, its head
+ * created there (it is then not drawn at the top), or its lifeline ended.
+ * Nothing changes for an unknown participant, or a second `create` of one.
+ */
+declare function insertMark(data: SequenceData, mark: SeqMark, at: StepPlace): SequenceData;
+/** Step `id` removed, with all a fragment holds. */
+declare function removeStep(data: SequenceData, id: string): SequenceData;
+/** The step at `at` removed: how a mark, which has no id, is taken out. */
+declare function removeStepAt(data: SequenceData, at: StepPlace): SequenceData;
+/**
+ * What `refs` name removed: each mark step at its place, and each message
+ * flag cleared. The places are read against `data` as given, so removing one
+ * does not shift the next. A place holding anything but a mark is left alone.
+ */
+declare function removeMarks(data: SequenceData, refs: readonly SeqMarkRef[]): SequenceData;
+/** Every `kind` mark naming `participant` removed, at any depth: a created head drawn at the top again, say. */
+declare function removeMarksOf(data: SequenceData, kind: SeqMark['kind'], participant: string): SequenceData;
+/** What {@link wrapSteps} takes. */
+interface NewSeqFragment {
+    type: SeqFragment['type'];
+    /** The first section's guard or title. */
+    label?: string;
+    /** Default a fresh `f` id. */
+    id?: string;
+}
+/**
+ * The steps of the list at `parent` from `start` up to (not including) `end`
+ * wrapped in a new fragment standing where they stood. An empty run makes an
+ * empty fragment at `start`. Nothing changes where `parent` names no list.
+ */
+declare function wrapSteps(data: SequenceData, parent: StepPlace['parent'], start: number, end: number, f: NewSeqFragment): SequenceData;
+/** Fragment `id` dissolved: its sections' steps, in order, stand where it stood. */
+declare function unwrapFragment(data: SequenceData, id: string): SequenceData;
+/** An empty section added to an alt, par, or critical, at `index` among its sections (default last). Other types hold one. */
+declare function addSection(data: SequenceData, id: string, label?: string, index?: number): SequenceData;
+/** Section `index` of fragment `id` removed, with its steps. A fragment's only section stays: remove the fragment instead. */
+declare function removeSection(data: SequenceData, id: string, index: number): SequenceData;
+/** Fragment `id` retyped. A fragment with several sections keeps them, so it takes only another type that holds several. */
+declare function setFragmentType(data: SequenceData, id: string, type: SeqFragment['type']): SequenceData;
+/** Message `id` drawn with `arrow`, a name in {@link SEQ_ARROWS} or an arrow of its own. */
+declare function setMessageArrow(data: SequenceData, id: string, arrow: SeqArrowName | SeqArrow): SequenceData;
+/** Message `id`'s activation flags set: which end it starts an activation on, and which end it ends one on; `undefined` clears one. */
+declare function setMessageActivation(data: SequenceData, id: string, flags: {
+    activate?: 'to' | 'from' | undefined;
+    deactivate?: 'to' | 'from' | undefined;
+}): SequenceData;
+
+/** The sizes a sequence is laid out with, and how its text is measured. */
+
+/** A box in world units. */
+interface SeqRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+/** Options for {@link sequenceLayout}. */
+interface SequenceLayoutOptions {
+    /** Measures text. Default an estimate from character count. */
+    measure?: MeasureRowText;
+    /** The face text is set in. Default 12px sans-serif. */
+    font?: {
+        fontFamily: string;
+        fontSize: number;
+    };
+}
+/** A head: at the top, or at its `create` row. */
+interface SeqHeadPlace {
+    id: string;
+    box: SeqRect;
+    created: boolean;
+}
+/** A lifeline, from under its head to the foot, or to where it was destroyed: by the `destroy` mark at `destroyedBy`. */
+interface SeqLifelinePlace {
+    id: string;
+    x: number;
+    y0: number;
+    y1: number;
+    destroyed: boolean;
+    destroyedBy?: StepPlace;
+}
+/** A message's line from `x1` (its `from` end) to `x2`, at `y`; a self-message loops down to `loopY`. */
+interface SeqMessagePlace {
+    id: string;
+    y: number;
+    x1: number;
+    x2: number;
+    loopY?: number;
+    text?: SeqRect;
+    number?: {
+        n: number;
+        box: SeqRect;
+    };
+}
+/** An activation bar, with what opened it and what closed it; one the diagram's end closed has no `closer`. */
+interface SeqActivationPlace {
+    participant: string;
+    depth: number;
+    box: SeqRect;
+    opener: SeqMarkRef;
+    closer?: SeqMarkRef;
+}
+interface SeqNotePlace {
+    id: string;
+    box: SeqRect;
+}
+/** A fragment's box, its type tab (none for a `region`), and each section's top and label. */
+interface SeqFragmentPlace {
+    id: string;
+    type: SeqFragment['type'];
+    box: SeqRect;
+    tab?: SeqRect;
+    sections: {
+        y: number;
+        label?: SeqRect;
+    }[];
+}
+interface SeqBoxPlace {
+    id: string;
+    box: SeqRect;
+    label?: SeqRect;
+}
+/** Where a dragged step dropped at `y` would go. */
+interface SeqSlot {
+    y: number;
+    place: StepPlace;
+}
+/** Every part of a sequence, placed. */
+interface SequenceLayout {
+    width: number;
+    height: number;
+    /** Lifeline x by participant, in data order. */
+    columns: readonly {
+        id: string;
+        x: number;
+    }[];
+    heads: readonly SeqHeadPlace[];
+    lifelines: readonly SeqLifelinePlace[];
+    messages: readonly SeqMessagePlace[];
+    activations: readonly SeqActivationPlace[];
+    notes: readonly SeqNotePlace[];
+    fragments: readonly SeqFragmentPlace[];
+    boxes: readonly SeqBoxPlace[];
+    /** Every place a step can be dropped, top to bottom. */
+    slots: readonly SeqSlot[];
+}
+/**
+ * Lays `data` out: lifelines spaced to the widest text between neighbors, a
+ * row per step sized to its text, self-messages looped, heads started at
+ * their `create` and lifelines ended at their `destroy`, nested activations
+ * stepped right, and each fragment boxed over the lifelines its steps touch.
+ */
+declare function sequenceLayout(data: SequenceData, opts?: SequenceLayoutOptions): SequenceLayout;
+
+/**
+ * `sequenceSpecs` — a sequence diagram as scene specs: one root holding the
+ * `SequenceData`, and every part drawn from it as a child the root owns. The
+ * parts take no press of their own; an edit replaces the root's data and
+ * builds them again.
+ */
+
+/** The theme role each kind of part is drawn in, where its data names none. */
+declare const SEQUENCE_ROLES: {
+    readonly note: "warning";
+    readonly number: "accent";
+};
+/** Options for {@link sequenceSpecs}. */
+interface SequenceSpecsOptions<TLayer extends string = 'main'> {
+    /** The root's id; every part's id starts with it. */
+    id: string;
+    /** Where the diagram's top-left corner stands. Default the origin. */
+    at?: Vec2$1;
+    /** Default `'main'`. */
+    layer?: TLayer;
+    /** Default the night theme. */
+    theme?: DiagramTheme;
+    /** Default the theme's face. */
+    font?: {
+        fontFamily: string;
+        fontSize: number;
+    };
+    /** Measures text. Default an estimate from character count. */
+    measure?: MeasureRowText;
+    /** How the scene folds a child's pose into its parent's. Default `RIGID_POSE_COMPOSITION`. */
+    composition?: PoseComposition<RectPose>;
+}
+/**
+ * The root and parts of a sequence diagram: its root at `at`, sized to the
+ * layout, holding `data`; boxes, fragments, lifelines, activations, messages,
+ * notes, and heads drawn over one another in that order, each from the
+ * theme's roles, its own colors over them.
+ */
+declare function sequenceSpecs<TLayer extends string = 'main'>(data: SequenceData, opts: SequenceSpecsOptions<TLayer>): DiagramSpec<TLayer>[];
+
+/**
+ * What a sequence's scene nodes carry under `data.diagram`: the root holds the
+ * whole `SequenceData`, and every part drawn from it names its root and what
+ * it draws.
+ */
+
+/** Where a root's parts stand, in its own frame: what a drag reads to place a drop without laying the data out again. */
+interface SequenceGeometry {
+    columns: readonly {
+        id: string;
+        x: number;
+    }[];
+    slots: readonly SeqSlot[];
+    heads: readonly {
+        id: string;
+        box: SeqRect;
+    }[];
+    messages: readonly SeqMessagePlace[];
+    notes: readonly {
+        id: string;
+        box: SeqRect;
+    }[];
+    /** Where a fragment is taken hold of: its type tab, or a region's top edge. Absent on a root drawn before fragments could be. */
+    fragments?: readonly {
+        id: string;
+        grip: SeqRect;
+    }[];
+    /** Where a box is taken hold of: the strip above its heads that holds its label. Absent as for `fragments`. */
+    boxes?: readonly {
+        id: string;
+        grip: SeqRect;
+    }[];
+    /** Where a part drawn for lifeline marks is taken hold of, by the part's id under the root: an activation bar, a
+     *  destruction's cross. Absent as for `fragments`. */
+    marks?: readonly {
+        id: string;
+        grip: SeqRect;
+    }[];
+}
+/** The trait on a sequence's root. */
+interface SequenceRootTrait {
+    sequence: SequenceData;
+    geometry: SequenceGeometry;
+}
+/** What a part draws. */
+type SeqPartKind = 'head' | 'lifeline' | 'destroy' | 'message' | 'activation' | 'note' | 'fragment' | 'divider' | 'box' | 'number' | 'text';
+/** The trait on a part of a sequence: its root, what it draws, and for text, what an edit of it sets. */
+interface SeqPartTrait {
+    root: string;
+    part: SeqPartKind;
+    /** The participant or step it draws. */
+    id?: string;
+    /** For text an edit can set. */
+    target?: SeqTextTarget;
+    /** For an activation bar or a destruction's cross: the marks and message flags that draw it, which deleting it removes. */
+    marks?: readonly SeqMarkRef[];
+}
+/** The sequence a root node holds, or `null` for any other node. */
+declare function sequenceRootOf(node: {
+    data: unknown;
+}): SequenceRootTrait | null;
+/** The part trait a node drawn for a sequence carries, or `null`. */
+declare function sequencePartOf(node: {
+    data: unknown;
+}): SeqPartTrait | null;
+
+/** Editing a sequence's text in place, through a canvas's own text editor. */
+
+/** Whether `data` is a sequence's text an edit can set: a head's, a message's or note's, a section's, a box's. */
+declare const isSequenceText: (data: unknown) => boolean;
+/**
+ * The `<SceneCanvas textEditor>` options that open on a sequence's text and,
+ * as the edit closes, fold it into one edit of the sequence's data for
+ * `report`. `undefined` while `report` is.
+ */
+declare function useSequenceTextEdit(scene: Scene<unknown, string, unknown>, report: ((edit: SequenceEdit) => void) | undefined): Exclude<SceneCanvasTextEditor<DiagramSceneData>, false> | undefined;
+
+/**
+ * What makes a sequence's parts grabbable: a head, a message or note, a
+ * fragment's tab, a box's label strip, an activation bar, a destruction's
+ * cross, and each end of a message, as regions over every sequence root in the scene.
+ * The parts themselves take no press, so these regions are the only way in.
+ */
+
+/** The layer id the sequence regions are composed into. */
+declare const SEQUENCE_LAYER_ID = "diagram-sequence";
+/** The affordance kind a press on a sequence part reports. */
+declare const SEQUENCE_AFFORDANCE_KIND: "layer:diagram-sequence";
+/** What a press on a sequence part hands the sequence actions, as the hit's `payload`. */
+interface SequenceScratch {
+    targetId: string;
+    /** The sequence root's id. */
+    root: string;
+    /** A head, a message's, note's or fragment's row, one end of a message, a box, or a part drawn for lifeline marks. */
+    part: 'head' | 'step' | 'end' | 'box' | 'mark';
+    /** The participant's, step's, or box's id; for a mark's part, the part's id under the root (`act:0`). */
+    id: string;
+    end?: 'from' | 'to';
+}
+/** Read a sequence press's scratch back off the hit an action was handed. */
+declare function sequenceScratchOf(hit: {
+    payload?: unknown;
+} | null | undefined): SequenceScratch | null;
+
+/**
+ * Dragging a sequence's parts: a message or note to another row, a head to
+ * another column, a message's end to another lifeline. Each drag previews the
+ * parts it carries and, on release, hands one edit of the root's data to
+ * `commit`, which by default replaces it in the scene as one undo entry.
+ */
+
+/** The action that drags a sequence part. */
+declare const SEQUENCE_DRAG_ACTION_ID = "diagram.sequence.drag";
+/** The action that absorbs the rest of a press on a sequence part, so it reaches neither marquee nor pan. */
+declare const GRAB_SEQUENCE_ACTION_ID = "diagram.sequence.grab";
+/** The `diagram.sequence.drag` action: an ongoing drag of whatever sequence part was pressed. */
+declare function createSequenceDragAction(opts?: SequenceEditOptions): Action;
+/**
+ * Both halves of sequence editing: the layer to `registerLayer` — last, so a
+ * sequence part wins over anything beside it — and the contribution to pass
+ * as `ambient`, which carries the drag. Like `diagramPorts`, one without the
+ * other fails quietly. Text is edited in place by the host's text editor,
+ * through `foldSequenceText`.
+ */
+declare function diagramSequence(opts: SequenceEditOptions & {
+    scene: Scene<unknown, string, unknown>;
+}): {
+    layer: RenderLayer<unknown>;
+    contribution: Contribution;
+};
+
+/**
+ * The clicks that author a sequence: a lifeline added where the click falls
+ * between two, or a new sequence started on empty canvas; a note dropped on
+ * the row nearest the click. Each hands one edit of the root's data to the
+ * commit, by default one undo entry in the scene.
+ */
+
+/** The action a Participant tool's click runs. */
+declare const ADD_PARTICIPANT_ACTION_ID = "diagram.sequence.addParticipant";
+/** The action a Note tool's click runs. */
+declare const ADD_NOTE_ACTION_ID = "diagram.sequence.addNote";
+/** The action a Mark tool's click runs. */
+declare const ADD_MARK_ACTION_ID = "diagram.sequence.addMark";
+/** Options for the sequence authoring actions. */
+interface SequenceAuthorOptions extends SequenceEditOptions {
+    /**
+     * Starts a new sequence holding `data` with its top-left corner at `at`, for
+     * a Participant click on empty canvas. Default {@link startSequence} against
+     * the scene when `commit` is the default; with a `commit` of its own and no
+     * `start`, a click off every sequence does nothing.
+     */
+    start?: ((at: Vec2, data: SequenceData, deps: ActionDeps) => void) | null;
+}
+/** Within this many world units of a lifeline, a note click lands over it rather than beside it. */
+declare const NOTE_OVER_REACH = 20;
+/** The Participant tool's action: a click on a sequence adds a lifeline there, of `params.kind`; one off every sequence starts one. */
+declare function createAddParticipantAction(opts?: SequenceAuthorOptions): Action;
+/** The Note tool's click: a note on the row nearest the click, over or beside the nearest lifeline. */
+declare function createAddNoteAction(opts?: SequenceEditOptions): Action;
+/**
+ * The Mark tool's click: a mark of `params.mark` (default `activate`) on the
+ * lifeline nearest the click, at the row slot nearest it: an activation
+ * starting or ending, the head created there, or the lifeline ended.
+ */
+declare function createAddMarkAction(opts?: SequenceEditOptions): Action;
+
+/**
+ * The drags that author a sequence: a message from one lifeline to another
+ * (or back to itself), a note spanning the lifelines dragged across, and a
+ * fragment wrapping the rows dragged across. Each previews what it would add
+ * as gesture chrome and, on release, hands one edit of the root's data to the
+ * commit, by default one undo entry in the scene.
+ */
+
+/** The action a Message tool's drag runs. */
+declare const DRAW_MESSAGE_ACTION_ID = "diagram.sequence.drawMessage";
+/** The action a Note tool's drag runs. */
+declare const DRAW_NOTE_ACTION_ID = "diagram.sequence.drawNote";
+/** The action a Fragment tool's drag runs. */
+declare const WRAP_FRAGMENT_ACTION_ID = "diagram.sequence.wrapFragment";
+/**
+ * The Message tool's drag: from the lifeline nearest the press to the one
+ * nearest the release, inserted at the row slot nearest the press, drawn with
+ * `params.arrow`. Released back on its own lifeline, it is a self-message.
+ */
+declare function createDrawMessageAction(opts?: SequenceEditOptions): Action;
+/**
+ * The Note tool's drag: a note over every lifeline from the one nearest the
+ * press to the one nearest the release, on the row slot nearest the press.
+ * Released on the lifeline it started on, it lands as a click there would.
+ */
+declare function createDrawNoteAction(opts?: SequenceEditOptions): Action;
+/**
+ * The Fragment tool's drag: a fragment of `params.type` (default `loop`)
+ * wrapping the rows between the slot nearest the press and the slot in the
+ * same list nearest the pointer. A still release wraps nothing, leaving an
+ * empty fragment to drag rows into.
+ */
+declare function createWrapFragmentAction(opts?: SequenceEditOptions): Action;
+
+/**
+ * Picking a sequence's parts and deleting them. A click on a head, a message,
+ * a note, a fragment's tab, or a box's label strip selects the scene node that
+ * draws it; Delete on a selection holding such nodes removes what they draw
+ * from their root's data, one edit per root, and the rest of the selection as
+ * core's delete would.
+ */
+
+/** The action a click on a sequence part runs. */
+declare const SELECT_SEQUENCE_PART_ACTION_ID = "diagram.sequence.select";
+type AnyScene$1 = Scene<unknown, string, unknown>;
+/** The id of the node that draws what `s` names, among its root's parts: a head, a message, a note, a fragment's box, a box. */
+declare function sequencePartNodeOf(scene: AnyScene$1, s: Pick<SequenceScratch, 'root' | 'part' | 'id'>): string | null;
+/** The sequence part's click: selects the node drawing it, or with Shift adds it to the selection or takes it out. */
+declare const selectSequencePartAction: Action;
+/**
+ * `ids` split into the sequence edits deleting them make, one per root, and
+ * the ids that are no sequence's part. An activation bar or a destruction's
+ * cross removes the marks and message flags that draw it. A part that draws
+ * nothing an edit can remove (a number, a section label) is dropped.
+ */
+declare function sequenceDeletes(scene: AnyScene$1, ids: readonly string[]): {
+    edits: {
+        id: string;
+        data: SequenceData;
+    }[];
+    rest: string[];
+};
+/** Options for {@link createSequenceDeleteAction}. */
+interface SequenceDeleteOptions extends SequenceEditOptions {
+    /** Deletes the selected ids that are no sequence's part. Default core's `commitDeleteToScene`. */
+    others?: (ids: readonly NodeId[], deps: ActionDeps) => void;
+}
+/**
+ * Core's `delete`, for a canvas holding sequences: the selected sequence parts
+ * are removed from their roots' data (a head takes its participant and what
+ * names it), the rest go to `others`, and the selection is emptied.
+ */
+declare function createSequenceDeleteAction(opts?: SequenceDeleteOptions): Action;
+
+/**
+ * What a selection names in a sequence: the root it is in, and the
+ * participants, messages, notes, fragments, and boxes its parts draw. What a
+ * host's panel reads to offer the edits that apply to a selection.
+ */
+
+type AnyScene = Scene<unknown, string, unknown>;
+/** A selection read as one sequence's parts. Each list is in selection order, without repeats. */
+interface SequenceSelection {
+    /** The root's id. */
+    root: string;
+    data: SequenceData;
+    participants: string[];
+    messages: string[];
+    notes: string[];
+    fragments: string[];
+    boxes: string[];
+}
+/**
+ * The sequence `ids` select in: the root of the first sequence part among
+ * them, or a selected root, else the scene's only sequence (with nothing
+ * selected in it), else `null`. Parts of any other root are left out.
+ */
+declare function sequenceSelectionOf(scene: AnyScene, ids: readonly string[]): SequenceSelection | null;
+
+/**
+ * The sequence authoring tools: each a declarative shell binding a click or a
+ * drag to the action that owns the edit. Every binding comes twice, once
+ * plain and once on the sequence layer's regions, since a press on a head,
+ * message, or note is claimed by that layer and reaches only bindings that
+ * name it.
+ */
+
+/** The ids `useSequenceTools` keys its tools by. */
+type SequenceToolId = 'diagram.sequence.participant' | 'diagram.sequence.message' | 'diagram.sequence.note' | 'diagram.sequence.fragment' | 'diagram.sequence.mark';
+/** The sequence authoring tools: lifelines, messages, notes, fragments, and lifeline marks. */
+declare const SEQUENCE_TOOLS: ToolSet<SequenceToolId>;
+/** Options for {@link sequenceTools} and {@link useSequenceTools}. */
+interface SequenceToolsOptions extends SequenceAuthorOptions {
+    /** What the Participant tool adds, read at each click. Default a plain participant. */
+    participant?: () => SeqParticipantKind;
+    /** The arrow the Message tool draws, read as each drag moves. Default `'sync'`. */
+    arrow?: () => SeqArrowName | SeqArrow;
+    /** The type the Fragment tool wraps rows in, read as each drag moves. Default `'loop'`. */
+    fragment?: () => SeqFragment['type'];
+    /** The mark the Mark tool puts on a lifeline, read at each click. Default `'activate'`. */
+    mark?: () => SeqMark['kind'];
+}
+/**
+ * Every tool in {@link SEQUENCE_TOOLS}, keyed by id, for `<SceneCanvas tools>`:
+ * Participant clicks a lifeline in where the click falls (or starts a sequence
+ * on empty canvas), Message drags from one lifeline to another at the row of
+ * the press, Note clicks or drags across lifelines, Fragment drags across
+ * rows to wrap them, and Mark clicks an activation's start or end, a
+ * creation, or a destruction onto a lifeline. Each commits one undo entry
+ * through `commit`.
+ */
+declare function sequenceTools(opts?: SequenceToolsOptions): Record<SequenceToolId, Tool>;
+/**
+ * {@link sequenceTools}, built once per change of what draws an edit. The
+ * commit and the participant, arrow, fragment, and mark readers are read through a
+ * ref, so a host can pass fresh closures every render.
+ */
+declare function useSequenceTools(opts?: SequenceToolsOptions): Record<SequenceToolId, Tool>;
+
+export { ADD_LANE_ACTION_ID, ADD_MARK_ACTION_ID, ADD_NOTE_ACTION_ID, ADD_PARTICIPANT_ACTION_ID, ARCHITECTURE_GROUP, ARCHITECTURE_STENCILS, ARCHITECTURE_TYPE, type ApplyDiagramThemeOptions, type ApplyLayoutOptions, AvoidInput, AvoidOptions, AvoidRouter, AvoidRoutes, type AvoidRouting, type AvoidRoutingOptions, type AvoidSceneOptions, BLOCK_TYPE, BPMN_GROUP, BPMN_STENCILS, BPMN_TYPE, type BodyEnd, type BodyHit, BodySpec, Bounds$2 as Bounds, C4_GROUP, C4_STENCILS, C4_TYPE, CONNECTOR_ACTION_ID, CONNECTOR_TOOL_ID, CONNECT_ACTION_ID, CONTAINERS_GROUP, CONTAINER_HEADER, CONTAINER_LAYOUTS, CONTAINER_STENCILS, type CanConnect, type CanDropItem, type CanReparent, type ConnectActionOptions, type ConnectEnd, type ConnectView, type ContainerBuildOptions, type ContainerEdit, ContainerHeader, type ContainerLayoutOptions, ContainerRole, type ContainerStencil, DEFAULT_EDGE_STROKE, DEFAULT_EDGE_STYLE, DEFAULT_GROUP_STYLE, DIAGRAM_CONTAINER_LAYOUT, DIAGRAM_EDGE, DIAGRAM_ITEM_CARRY, DIAGRAM_LABEL, DIAGRAM_LANE_COLUMNS_LAYOUT, DIAGRAM_LANE_ROWS_LAYOUT, DIAGRAM_OFF_PAGE_TAG, DIAGRAM_PASS_ORDER, DIAGRAM_POOL_COLUMNS_LAYOUT, DIAGRAM_POOL_ROWS_LAYOUT, DIAGRAM_THEMES, DIAGRAM_THEME_EXTENSION, DIAGRAM_TYPES, DIAGRAM_TYPE_DOC_KEY, DRAW_MESSAGE_ACTION_ID, DRAW_NOTE_ACTION_ID, DataContainer, DataEdge, DataNode, type DeleteReport, DiagramContainer, type DiagramContributionOptions, DiagramData, DiagramEdge, DiagramLabel, type DiagramLayout, DiagramNodeLike, DiagramNodeReader, type DiagramOverlay, DiagramSceneData, DiagramSceneOptions, type DiagramShapeOptions, DiagramSpec, type DiagramStencil, type DiagramStyleEditOptions, type DiagramStyleState, DiagramTheme, type DiagramType, type DiagramTypeDoc, type DiagramTypeEdge, type DiagramTypeReadable, type DiagramTypeScene, type DiagramTypeWriteOptions, DiagramView, type DiagramViewApi, type DiagramViewProps, type DraggableLabel, type DropParentScene, EASED_LAYOUTS, EDGE_DERIVE_PATH, EDGE_END_AFFORDANCE_KIND, EDGE_END_LAYER_ID, EDIT_CONTAINER_TITLE_ACTION_ID, EDIT_EDGE_LABEL_ACTION_ID, END_LABEL_PLACEMENT, ERD_GROUP, ERD_STENCILS, ERD_TYPE, type EasedProducerOptions, EdgeEnd, type EdgeEndAffordanceOptions, type EdgeEndScratch, EdgeHop, type EdgeLabelOptions, type EdgeRoute, type EdgeRouteOptions, type EdgeRouteState, EdgeStyle, type EditEdgeLabelOptions, type EndChange, FLOWCHART_GROUP, FLOWCHART_NOTATION, FLOWCHART_STENCILS, FLOWCHART_TYPE, FOLLOW_OFF_PAGE_ACTION_ID, type FollowOffPageOptions, FontField, ForceOptions, type ForceProducerOptions, GRAB_EDGE_END_ACTION_ID, GRAB_LABEL_ACTION_ID, GRAB_PORT_ACTION_ID, GRAB_SEQUENCE_ACTION_ID, GRAB_WAYPOINT_ACTION_ID, Graph, GraphNodeLike, GraphSource, type Hops, type HopsOptions, ITEM_DROP_ACTION_ID, type ItemDrop, type ItemDropOptions, type ItemDropTarget, KANBAN_GROUP, KANBAN_STENCILS, KANBAN_TYPE, LABEL_DERIVE_POSE, LABEL_DRAG_AFFORDANCE_KIND, LABEL_DRAG_LAYER_ID, LANE_AFFORDANCE_KIND, LANE_HEADER_SIZE, LANE_LAYER_ID, LANE_RESIZE_ACTION_ID, LAYOUTS, LAYOUT_ACTION_ID, type LabelDragOptions, type LabelEdit, type LabelMove, type LabelPlacement, type LabelPlacementOptions, type LabelPoseOptions, type LabelScratch, LabelSpot, type LaneActionOptions, type LaneLayerOptions, type LaneResize, type LaneScratch, type LaneStackOptions, type LayeredRoute, type LayeredRouteInput, type LayoutActionOptions, type LayoutDiagramOptions, LayoutDirection, LayoutFn, LayoutOptions, LayoutPlan, LayoutPlanner, LayoutPorts, LayoutResult, type LayoutRoutes, type LiveLayout, type LiveLayoutCtx, type LiveLayoutFrame, type LiveLayoutProducer, MIND_MAP_GROUP, MIND_MAP_STENCILS, MIND_MAP_TYPE, MIN_LANE_SIZE, MOVE_LABEL_ACTION_ID, MeasureRowText, type MovingEnd, NETWORK_GROUP, NETWORK_STENCILS, NETWORK_TYPE, NOTE_OVER_REACH, type NewSeqFragment, type NewSeqMessage, type NewSeqNote, type NodeMove, type NodeResize, NodeStyle, OFF_PAGE_STUB, OFF_PAGE_TAG_DERIVE_POSE, OFF_PAGE_TAG_PADDING, ORG_CHART_TYPE, ORG_GROUP, ORG_STENCILS, type OffPageEdgeInput, type OffPageMarkerOptions, OffPageSplit, type OffPageSplitInput, type OffPageTagLook, type OffPageTarget, Outline, POOL_HEADER_SIZE, PORT_AFFORDANCE_KIND, PORT_LAYER_ID, type ParticipantPose, type ParticipantScene, type ParticipantSource, type PendingEdge, PlaceLabelsOptions, type PoolLanes, Port, type PortAffordanceOptions, type PortScratch, PortsOptions, RECONNECT_ACTION_ID, RELEASE_MEMBERS_ACTION_ID, REMOVE_WAYPOINT_ACTION_ID, REORDER_ACTION_ID, REQUIREMENT_GROUP, REQUIREMENT_STENCILS, REQUIREMENT_TYPE, RESET_LABEL_ACTION_ID, RESET_ROUTE_ACTION_ID, ROUTERS, ROUTER_LABELS, ROUTE_EDIT_ACTION_ID, type ReconnectChange, type ReconnectOptions, type RegionOptions, type RegionSpec, type RelayoutScene, type ReorderChange, type ReorderGap, type ReorderItem, type ReorderMove, type ReorderOptions, type ReorderSlots, type ResolvedRoute, type RouteChange, type RouteEdge, type RouteEdit, type RouteEditOptions, type RouteHandle, type RouteRequest, type RoutedScene, type Router, type RouterEdit, type RouterName, Row, RowTextStyle, SELECT_LABEL_EDGE_ACTION_ID, SELECT_SEQUENCE_PART_ACTION_ID, SEQUENCE_AFFORDANCE_KIND, SEQUENCE_DRAG_ACTION_ID, SEQUENCE_LAYER_ID, SEQUENCE_ROLES, SEQUENCE_TOOLS, SEQ_ARROWS, SEQ_MULTI_SECTION, SET_HOPS_ACTION_ID, SET_ROUTER_ACTION_IDS, STATE_GROUP, STATE_STENCILS, STATE_TYPE, STENCIL_GROUPS, STEP_REORDER_ACTION_ID, type SelfLoop, type SeqArrow, type SeqArrowName, type SeqBox, type SeqFragment, type SeqIdStep, type SeqMark, type SeqMarkRef, type SeqMessage, type SeqNote, type SeqPartKind, type SeqPartTrait, type SeqParticipant, type SeqParticipantKind, type SeqRect, type SeqSection, type SeqSlot, type SeqStep, type SeqTextTarget, type SequenceAuthorOptions, type SequenceData, type SequenceDeleteOptions, type SequenceDrawOptions, type SequenceEdit, type SequenceEditOptions, type SequenceGeometry, type SequenceLayout, type SequenceLayoutOptions, type SequenceRootTrait, type SequenceScratch, type SequenceSelection, type SequenceSpecsOptions, type SequenceToolId, type SequenceToolsOptions, type SetHopsOptions, type SetRouterOptions, type SpecRouterOptions, StencilGhost, type StencilGhostProps, type StencilGroup, type StencilInsertOptions, type StepPlace, StyleField, type StyledRegion, type ThemePath, type ThemedNode, type ThemedScene, UML_CLASS_TYPE, UML_GROUP, UML_STENCILS, type UseLiveLayoutOptions, WAYPOINT_AFFORDANCE_KIND, WAYPOINT_HIT_PX, WAYPOINT_LAYER_ID, WRAP_FRAGMENT_ACTION_ID, type WaypointAffordanceOptions, type WaypointScratch, addBox, addLane, addParticipant, addSection, addStencilGroup, addThemeRole, applyDiagramTheme, applyLayout, avoid, avoidSceneInput, bezier, bodyAt, bodyFollower, commitEdgeToScene, commitLabelToScene, commitLaneResizeToScene, commitReconnectToScene, commitRouteToScene, commitRouterToScene, commitSequence, connectBinding, connectorTool, containerBuild, containerShape, createAddLaneAction, createAddMarkAction, createAddNoteAction, createAddParticipantAction, createConnectAction, createDiagramContribution, createDrawMessageAction, createDrawNoteAction, createEdgeEndAffordance, createFollowOffPageAction, createItemDropAction, createLabelDragAction, createLaneAffordance, createLaneResizeAction, createLayoutAction, createPortAffordance, createReconnectAction, createReleaseMembersAction, createRemoveWaypointAction, createReorderAction, createResetLabelAction, createResetRouteAction, createRouteEditAction, createSequenceDeleteAction, createSequenceDragAction, createSetHopsAction, createSetRouterAction, createSpecHops, createSpecLabelPlacer, createSpecRouter, createStepReorderAction, createWaypointAffordance, createWrapFragmentAction, dataEdgeStyle, dataNodeStyle, dataOffPage, dataRegionStyle, defaultCanConnect, diagramCanDropInto, diagramContainerLayout, diagramContainers, diagramDropParentAt, diagramEdgeEnds, diagramLabelDrag, diagramLayoutOf, diagramNotationOf, diagramOffPage, diagramPages, diagramPorts, diagramResizable, diagramScene, diagramSequence, diagramShape, diagramStyleOf, diagramThemeFrom, diagramThemeFromTokens, diagramThemeOf, diagramTypeDocOf, diagramTypeDocValue, diagramTypeEdgeStroke, diagramTypeOf, diagramTypeOfNotation, diagramWaypoints, documentBoundsOf, dragItemProps, dragSegment, dragVertex, draggableLabels, dropEmptyEdgeLabel, easedProducer, edgeDerivePath, edgeEndLayer, edgeEndScratchOf, edgeIdOf, edgeLabelSpec, edgeRouter, editContainerTitleAction, editContainerTitleBinding, editEdgeLabelAction, editEdgeLabelBinding, editableTheme, endLabelIdOf, findStep, firstLanes, foldSequenceText, followOffPageBinding, forceProducer, forkTheme, freshSeqId, grabPortAction, grabPortBindings, groupReorderContribution, groupReorderSlots, groupStencilIds, groupStencils, headerIdOf, hopFollower, insertMark, insertMessage, insertNote, insertStep, insertWaypoint, installAvoidRouting, installHops, installLabelPlacement, installOffPageMarkers, isBodyEnd, isBodyOrRegion, isContainerStencil, isDiagramBody, isSequenceText, isShippedTheme, itemDropContribution, labelDerivePose, labelDragLayer, labelScratchOf, labelSize, labelUnder, laneHeader, laneLayer, laneResizeFrame, laneScratchOf, laneStackLayout, lanesOf, layeredRoutes, layoutDiagram, layoutPoses, moveParticipant, moveStep, movedLabelData, newParticipant, nextOffPageRef, offPageFarText, offPageOps, offPageSplits, offPageTagData, offPageTagDerivePose, offPageTagLook, offPageTagSize, offPageTagSpec, offPageTagSpecs, offPageTagText, offPageTargetOf, orthogonal, parseDiagramTheme, pinSegment, placeOf, poolAxisOf, poolHeader, poolsOf, portLayer, portScratchOf, reconnectBinding, reconnectMessage, redrawSequences, regionHeaderAt, regionSpecs, registerDiagramShape, relayoutBodies, releaseMembers, removeBox, removeMarks, removeMarksOf, removeParticipant, removeSection, removeSegment, removeStencilGroup, removeStep, removeStepAt, removeThemeRole, removeWaypoint, renameThemeRole, rendererMeasure, reorderBinding, reorderContribution, resolveEnd, roleEdgeStyle, roleStyle, routeDataOps, routeHandles, routeStateOf, routeWrites, routedData, routerActions, routesOf, sceneParticipants, segmentAxis, selectSequencePartAction, selfLoop, seqIdTaken, sequenceCommitOf, sequenceDeletes, sequenceLayout, sequencePartNodeOf, sequencePartOf, sequenceRootOf, sequenceScratchOf, sequenceSelectionOf, sequenceSlots, sequenceSpecs, sequenceTextOf, sequenceTools, setAutonumber, setDiagramColor, setDiagramFontSize, setDiagramStyle, setDiagramType, setFragmentType, setMessageActivation, setMessageArrow, setParticipantOutline, setSequenceText, setThemeValue, simplifyStops, stackedLanes, startItemDrag, startSequence, stencilBuild, stencilIdOf, stencilKind, stencilTool, stepListOf, straight, subpathOf, themeDocValue, themeEdgeStroke, themeFont, themeLabelFont, themeLabelStyle, themeRoles, themeToJson, themeValue, themeWrites, titlePose, unpinSegment, unwrapFragment, useAvoidRouting, useConnectorTool, useHops, useLabelPlacement, useLiveLayout, useMirroredSelection, useOffPageMarkers, useSequenceTextEdit, useSequenceTools, useStencilInsert, useStencilTool, waypointFollower, waypointLayer, waypointScratchOf, withDiagramRegistry, withHops, withRouter, wrapSteps };