@weasel-js/diagram 1.13.0 → 1.14.0

package/dist/index.d.ts

@@ -1,16 +1,19 @@
-import { g as Port, h as DiagramNodeLike, i as DiagramNodeReader, O as Outline, a as Row, M as MeasureRowText, C as ContainerRole, j as DiagramContainer, k as ContainerHeader, c as DiagramLabel, l as LabelSpot, E as EdgeHop, R as RowTextStyle, m as Bounds$2, e as LayoutOptions, n as LayoutResult, G as Graph, d as LayoutFn, o as GraphSource, p as LayoutPlanner, q as LayoutDirection, L as LayoutPorts, r as LayoutPlan, s as GraphNodeLike, S as StyleField, F as FontField } from './types-vbW21fHm.js';
-export { t as BodyFloor, B as BodySpec, u as BuildGraphOptions, v as DEFAULT_GROUP_INSET, w as DEFAULT_HOP_SIZE, x as DEFAULT_NODE_GAP, y as DEFAULT_RANK_GAP, z as DIAGRAM_TRAIT_KEY, D as DiagramGroup, f as DiagramNode, A as DiagramNodeEntry, H as EdgeLabelRoom, I as GraphEdge, J as GraphGroup, K as GraphNode, N as GroupInset, Q as HOPS_DOC_KEY, T as HopsDocValue, U as LABEL_PLACEMENT, V as LayoutAxes, P as PortAnchor, W as PortSite, b as PortSpec, X as RowBox, Y as RowPort, Z as RowPortBox, _ as Slot, $ as anchorOffset, a0 as axesFor, a1 as bodyBox, a2 as bodyOutline, a3 as bodyTrait, a4 as boxForContent, a5 as buildGraph, a6 as canvasMeasure, a7 as contentBox, a8 as createDiagramNodes, a9 as dataKeyReader, aa as diagramContainerOf, ab as diagramLabelOf, ac as diagramNodeOf, ad as expandGroupEdges, ae as graphOrder, af as headerBox, ag as insetOf, ah as isPinned, ai as layoutBody, aj as layoutRowPorts, ak as measureBody, al as outlinePath, am as packAcross, an as packClusters, ao as pinnedSet, ap as planOf, aq as plannerPlan, ar as rankGaps, as as seededOrder, at as settle, au as sizeToBody, av as titleIdOf, aw as translated, ax as untilSettled } from './types-vbW21fHm.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-CQoPNfzA.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 outlinePolyline, S as placeLabels, T as portLabelBox, U as portLabelsOf, V as portOf, W as portSitesOf, X as portsOf, Y as portsOnOutline, Z as ranksByLength, _ as ranksOf, $ as rayHit, a0 as routeHolds, a1 as tree } from './layout.entry-CQoPNfzA.js';
-import { Vec2, ActionDeps, Action, InvocationCtx, TargetPredicate, GestureBinding, Contribution, DerivedDep, Path, SceneRegistry, paintsLayer, PoseDescriptor, ChromeState, CommandFill, CommandStroke, CursorSpec, Affordance, Stroke, Tool, Op, AddNodeSpec, RectPose, NodeId, Scene, LayoutStrategy, ContainerBounds, RenderLayer, TransformFollower, 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-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-Ca6pVvqo.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-Ca6pVvqo.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';
+export { DropRefusal, DropVerdict } from '@weasel-js/core';
 import { Vec2 as Vec2$1, Path as Path$2 } from '@weasel-js/core/math';
-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-DW-MljuN.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-DW-MljuN.js';
+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 { 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 { Path as Path$1, Placement } from '@weasel-js/geom';
 import { EasingFn } from '@weasel-js/animator';
-import * as react from 'react';
-import { ReactNode } from 'react';
 import '@weasel-js/simulation';
 
 /** The scene node id `diagramScene` gives an edge: its `id` when set, else one
@@ -105,6 +108,10 @@ interface ReorderOptions {
      * overrides stay after a commit until the scene next changes.
      */
     show?: 'bar' | 'slide';
+    /** Where a drag of `item` stays a reorder, in world units. A move outside it hands the drag off (`'pass'` from
+     *  `OngoingHandle.onMove`) to whatever else would have taken the press, a move for one, and drops this
+     *  drag's preview. `null`, or the default, keeps every move a reorder. */
+    region?: (deps: ActionDeps, item: ReorderItem) => Box$3 | null;
     /** Whether a drop may land. The bar draws refused, or nothing slides, where not. Default: every drop. */
     canDrop?: (move: ReorderMove) => boolean;
     /** Called once, on release over a gap that is not the item's own and that `canDrop` allows. */
@@ -307,8 +314,16 @@ declare function offersPorts(p: {
 }, view?: Parameters<typeof paintsLayer>[0]): boolean;
 /** Where the affordance gets its participants. A thunk rather than a scene so
  *  the geometry is testable without one, and so a consumer whose participants
- *  come from somewhere else needs no adapter. */
-type ParticipantSource<TPose> = () => Iterable<ParticipantPose<TPose>>;
+ *  come from somewhere else needs no adapter.
+ *
+ *  With `generation`, the ports are read once per generation, so a frame paints
+ *  them without reading any, and a press is tested against an index of them
+ *  rather than every one: it must answer differently whenever the thunk can yield
+ *  something different (`sceneParticipants` answers the scene's version and
+ *  its overrides' generation). */
+type ParticipantSource<TPose> = (() => Iterable<ParticipantPose<TPose>>) & {
+    generation?: () => readonly unknown[];
+};
 /** What a press on a port hands the action that picks up the drag. Arrives as
  *  `InvocationCtx.drag.affordance.payload`. */
 interface PortScratch {
@@ -360,6 +375,14 @@ declare function portScratchOf(hit: {
  */
 declare function createPortAffordance<TPose>(participants: ParticipantSource<TPose>, opts?: PortAffordanceOptions<TPose>): Affordance;
 
+/**
+ * What a connect may run from and land on: a port, or a participant's body.
+ *
+ * A body end is Visio's dynamic glue. It names the shape and not a port, and
+ * the edge resolves to whichever port faces the other end each time it is
+ * routed (`resolveEnd`), so it follows the shape around as things move.
+ */
+
 /** An end on a participant's body rather than on one of its ports. `point` is
  *  where the pointer was, in world coordinates. */
 interface BodyEnd {
@@ -418,9 +441,12 @@ interface MovingEnd {
     edge: string;
     end: 'from' | 'to';
 }
-/** Whether an edge may run from `from` to `to`. `moving` is the end being
- *  dragged when the edge already exists, and absent for a new connect. */
-type CanConnect = (from: ConnectEnd, to: ConnectEnd, moving?: MovingEnd) => boolean;
+/** Whether an edge may run from `from` to `to`: `true`, `false` for a silent
+ *  no, where the end never snaps, or a refusal, which the end snaps to and is
+ *  drawn refused with the reason beside the pointer, and where a release
+ *  lands nothing. `moving` is the end being dragged when the edge already
+ *  exists, and absent for a new connect. */
+type CanConnect = (from: ConnectEnd, to: ConnectEnd, moving?: MovingEnd) => DropVerdict;
 /** The edge a finished connect describes. Each end is a resolved port, or a
  *  body whose port the edge picks each time it is routed. */
 interface PendingEdge {
@@ -519,6 +545,68 @@ declare function commitEdgeToScene(edge: PendingEdge, ctx: InvocationCtx, opts?:
  */
 declare function createConnectAction<TPose>(opts: ConnectActionOptions<TPose>): Action;
 
+/**
+ * Where an item carried in from outside the canvas would land: the shape or
+ * container under the pointer, the container that would hold it, and its
+ * place among that container's members.
+ */
+
+/** Where a carried item is over. */
+interface ItemDropTarget {
+    /** The shape or the container it would be dropped on, or `null` for the bare canvas. */
+    target: string | null;
+    /** The container or lane that would hold it: the target when that is one,
+     *  else the one around the pointer. `null` at the top level. */
+    container: string | null;
+    /** Its place among `container`'s members, as they stand along the
+     *  container's `reorder` axis, else in reading order: top to bottom, then
+     *  left to right. `null` with no container. */
+    index: number | null;
+    /** The pointer, in world units. */
+    at: Vec2;
+}
+
+/**
+ * An item carried in from a list outside the canvas — a palette the host
+ * renders — and dropped onto a shape, a container, or the bare canvas. The
+ * host makes an element a source with {@link dragItemProps}; the canvas hears
+ * the carry, draws where it would land, and reports the drop. Nothing is
+ * written: the host adds what the item stands for to its data.
+ */
+
+/** The carry type an item travels as. */
+declare const DIAGRAM_ITEM_CARRY = "weasel-diagram/item";
+/** The action a carried item's drop runs. */
+declare const ITEM_DROP_ACTION_ID = "diagram.dropItem";
+/** An item dropped on the diagram: the host's own value, and where it landed. */
+interface ItemDrop extends ItemDropTarget {
+    item: unknown;
+}
+/** Whether `item` may land where `target` says. */
+type CanDropItem = (item: unknown, target: ItemDropTarget) => DropVerdict;
+/** Carry `item` from the press `down` over the page; a diagram the pointer is
+ *  released over reports it to `onDropItem`. */
+declare function startItemDrag(down: PointerEvent | PointerEvent$1, item: unknown, cb?: CarryCallbacks): Carry;
+/** Props that make an element a source of `item`: a press with the main
+ *  button carries it. Give the element `touch-action: none` for touch. */
+declare function dragItemProps(item: unknown, cb?: CarryCallbacks): {
+    onPointerDown: (e: PointerEvent$1) => void;
+};
+/** Options for {@link createItemDropAction}. */
+interface ItemDropOptions {
+    participants: ParticipantSource<RectPose>;
+    /** Default: every drop lands. */
+    canDrop?: CanDropItem;
+    /** Deps `report` reads beyond the scene, such as `insert` and `snap` to add the item itself. */
+    requires?: readonly DepName[];
+    /** Hears a drop that lands, with the canvas's deps as the carry came over it: `scene` and whatever `requires` names. */
+    report: (drop: ItemDrop, deps: ActionDeps) => void;
+}
+/** The ongoing action a carried item runs from coming over the canvas to its release. */
+declare function createItemDropAction(opts: ItemDropOptions): Action;
+/** The item drop as a contribution, to pass as `ambient`. */
+declare function itemDropContribution(opts: ItemDropOptions): Contribution;
+
 /** The connector tool's id. */
 declare const CONNECTOR_TOOL_ID = "diagram.connector";
 /** The action the connector tool binds a drag to. */
@@ -530,59 +618,6 @@ declare function connectorTool<TPose>(opts: ConnectActionOptions<TPose>): Tool;
  *  when the bag holding them does. */
 declare function useConnectorTool<TPose>(opts: ConnectActionOptions<TPose>): Tool;
 
-/**
- * Stencils: the shapes a palette offers, as data, and what one becomes when it
- * is drawn — a `buildBody` body whose rows are ordinary text nodes.
- */
-
-/** One shape a palette offers. `size` is what a click places; `rows` default
- *  to one empty label, so the body has a text node to type into. `icon` is its
- *  tool's glyph in a palette. */
-interface DiagramStencil {
-    id: string;
-    label: string;
-    outline: Outline;
-    size: {
-        width: number;
-        height: number;
-    };
-    rows?: readonly Row[];
-    icon?: IconRef;
-}
-/** The basic flowchart symbols. */
-declare const FLOWCHART_STENCILS: readonly DiagramStencil[];
-/** The insert kind a stencil's tool passes to the `insert` dep. */
-declare const stencilKind: (id: string) => string;
-/** The stencil id an insert kind names, or `null` for a kind that is no stencil's. */
-declare function stencilIdOf(kind: string): string | null;
-type Bounds$1 = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-/**
- * The ops that insert `stencil` at `bounds`: its container first, then one
- * text node per text row. Applied as one batch, they are one undo entry.
- * `style` colors the body and its text; default `diagramScene`'s node style.
- * `font` is the face its text rows fall back on; default 12px sans-serif.
- * `parent` is the container the body goes in; default the top level.
- */
-declare function stencilBuild<TLayer extends string>(stencil: DiagramStencil, bounds: Bounds$1, opts: {
-    layer: TLayer;
-    newId: () => string;
-    measure?: MeasureRowText;
-    style?: NodeStyle;
-    font?: {
-        fontFamily: string;
-        fontSize: number;
-    };
-    parent?: string | null;
-}): {
-    id: string;
-    ops: Op[];
-};
-
 /**
  * The node specs of a region — a container, a pool, or a lane — and its title,
  * which a stencil drawn on the canvas and a `DiagramData` container both build
@@ -617,6 +652,8 @@ interface RegionOptions<TLayer extends string> {
     style?: NodeStyle;
     /** Marks a region whose box is fitted to its members each time it is built from data. */
     fitted?: boolean;
+    /** A container's reorder axis. */
+    reorder?: 'x' | 'y';
     /** The title's family. Default sans-serif. */
     fontFamily?: string;
 }
@@ -625,6 +662,11 @@ declare function regionSpecs<TLayer extends string>(role: ContainerRole, axis: '
 /** 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>[];
 
+/** A titled box, and pools of rows and of columns. */
+declare const CONTAINER_STENCILS: readonly ContainerStencil[];
+/** The containers as a stencil group. */
+declare const CONTAINERS_GROUP: StencilGroup;
+
 /**
  * The container stencils a palette offers, what one becomes when it is drawn,
  * and the edits on one: adding a lane to a pool, and releasing a container's
@@ -644,37 +686,172 @@ interface ContainerStencil {
     /** The glyph a palette draws on its button. */
     icon?: IconRef;
 }
-/** A titled box, and pools of rows and of columns. */
-declare const CONTAINER_STENCILS: readonly ContainerStencil[];
-type Bounds = {
+
+type Bounds$1 = {
     x: number;
     y: number;
     width: number;
     height: number;
 };
-type AnyScene$3 = Scene<unknown, string, unknown>;
+type AnyScene$4 = 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, opts: ContainerBuildOptions<TLayer>): {
+declare function containerBuild<TLayer extends string>(stencil: ContainerStencil, bounds: Bounds$1, opts: ContainerBuildOptions<TLayer>): {
     id: string;
     ops: Op[];
 };
 /** 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$3, poolId: string): NodeId[];
+declare function lanesOf(scene: AnyScene$4, 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$3, poolId: string, index?: number, style?: NodeStyle): string | null;
+declare function addLane(scene: AnyScene$4, 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$3, id: string): void;
+declare function releaseMembers(scene: AnyScene$4, id: string): void;
+
+/**
+ * The commands that set the selected connectors' router: Around shapes,
+ * Orthogonal, Straight, and Curved. Leaving `avoid` drops the stored route;
+ * joining it leaves the route to the edit pass `useAvoidRouting` installs,
+ * which routes the connectors in the same history entry.
+ */
+
+/** The router commands' ids, by router key. */
+declare const SET_ROUTER_ACTION_IDS: {
+    readonly avoid: "diagram.router.avoid";
+    readonly orthogonal: "diagram.router.orthogonal";
+    readonly straight: "diagram.router.straight";
+    readonly bezier: "diagram.router.bezier";
+};
+/** Each shipped router's name in a menu. */
+declare const ROUTER_LABELS: Readonly<Record<keyof typeof SET_ROUTER_ACTION_IDS, string>>;
+/** One connector's router changed. */
+interface RouterEdit {
+    edgeId: string;
+    router: string;
+}
+/** Options for {@link createSetRouterAction}. */
+interface SetRouterOptions<TPose> {
+    participants: ParticipantSource<TPose>;
+    /** The selected ids; the connectors among them are set. */
+    selected: () => readonly string[];
+    /** Defaults to {@link commitRouterToScene} against `deps.scene`. */
+    commit?: (edit: RouterEdit, ctx: InvocationCtx) => void;
+}
+/** `data` with its edge trait on `router`, its stored route dropped. */
+declare function withRouter(data: unknown, trait: DiagramEdge, router: string): Record<string, unknown>;
+/** The default commit: the connector's `data.diagram.router`, written to the scene. */
+declare function commitRouterToScene(edit: RouterEdit, ctx: InvocationCtx): void;
+/** The command that puts the selected connectors on `router`, in one history
+ *  entry. Active while every selected connector is on it already. */
+declare function createSetRouterAction<TPose>(router: keyof typeof SET_ROUTER_ACTION_IDS, opts: SetRouterOptions<TPose>): Action;
+/** One command per shipped router, in menu order. */
+declare function routerActions<TPose>(opts: SetRouterOptions<TPose>): Action[];
+
+/** A shipped connector router, by key. */
+type RouterName = keyof typeof SET_ROUTER_ACTION_IDS;
+/** A named list of stencils: the flowchart symbols, the containers. */
+interface StencilGroup {
+    id: string;
+    label: string;
+    stencils: readonly (DiagramStencil | ContainerStencil)[];
+}
+/** What a new connector is drawn with. An unset field falls to the theme. */
+interface DiagramTypeEdge {
+    router?: RouterName;
+    markerStart?: MarkerRef | null;
+    markerEnd?: MarkerRef | null;
+}
+/** A kind of diagram: the stencil groups a new one opens with, how its connectors start out, and the
+ *  layout Auto layout runs. */
+interface DiagramType {
+    id: string;
+    label: string;
+    icon?: IconRef;
+    /** Group ids, in Shapes-panel order, that a new chart of this type opens with. */
+    groups: readonly string[];
+    edge?: DiagramTypeEdge;
+    /** A key of `LAYOUTS`. Unset: no auto layout. */
+    layout?: 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 document value a diagram's type and shown stencil groups are saved under. */
+declare const DIAGRAM_TYPE_DOC_KEY = "diagram:type";
+
+/** The basic flowchart symbols. */
+declare const FLOWCHART_STENCILS: readonly DiagramStencil[];
+/** The flowchart symbols as a stencil group. */
+declare const FLOWCHART_GROUP: StencilGroup;
+
+/**
+ * Stencils: the shapes a palette offers, as data, and what one becomes when it
+ * is drawn — a `buildBody` body whose rows are ordinary text nodes.
+ */
+
+/** One shape a palette offers. `size` is what a click places; `rows` default
+ *  to one empty label, so the body has a text node to type into. `icon` is its
+ *  tool's glyph in a palette. */
+interface DiagramStencil {
+    id: string;
+    label: string;
+    outline: Outline;
+    size: {
+        width: number;
+        height: number;
+    };
+    rows?: readonly Row[];
+    icon?: IconRef;
+    /** Laid over the style the body is drawn in: a BPMN end event's heavier ring. */
+    style?: Partial<NodeStyle>;
+    /** How its body stacks its rows, as `BodySpec`'s fields of the same names. */
+    padding?: number;
+    gap?: number;
+    verticalAlign?: BodySpec['verticalAlign'];
+}
+
+/** The insert kind a stencil's tool passes to the `insert` dep. */
+declare const stencilKind: (id: string) => string;
+/** The stencil id an insert kind names, or `null` for a kind that is no stencil's. */
+declare function stencilIdOf(kind: string): string | null;
+type Bounds = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * The ops that insert `stencil` at `bounds`: its container first, then one
+ * text node per text row. Applied as one batch, they are one undo entry.
+ * `style` colors the body and its text; default `diagramScene`'s node style.
+ * `font` is the face its text rows fall back on; default 12px sans-serif.
+ * `parent` is the container the body goes in; default the top level.
+ */
+declare function stencilBuild<TLayer extends string>(stencil: DiagramStencil, bounds: Bounds, opts: {
+    layer: TLayer;
+    newId: () => string;
+    measure?: MeasureRowText;
+    style?: NodeStyle;
+    font?: {
+        fontFamily: string;
+        fontSize: number;
+    };
+    parent?: string | null;
+}): {
+    id: string;
+    ops: Op[];
+};
 
 /** The tool that draws `stencil`, a shape's or a container's: its id is the stencil's insert kind. */
 declare function stencilTool(stencil: Pick<DiagramStencil, 'id' | 'label' | 'icon'>): Tool;
@@ -710,6 +887,20 @@ interface StencilInsertOptions {
  */
 declare function useStencilInsert(stencils: readonly DiagramStencil[], opts?: StencilInsertOptions): void;
 
+/** Props for {@link StencilGhost}. */
+interface StencilGhostProps {
+    stencil: DiagramStencil | ContainerStencil;
+    /** What it is drawn in: the style its body is inserted with. A stencil's own `style` is laid over it. */
+    style: NodeStyle;
+    /** Screen pixels per world unit, so it is drawn at the size it lands at under the view's zoom. Default 1. */
+    scale?: number;
+}
+/**
+ * `stencil`'s outline as an SVG, the size a click would place it at, in `style`: what a drag from a palette shows
+ * on its way to the canvas. A container draws its frame. Holds no text.
+ */
+declare function StencilGhost({ stencil, style, scale }: StencilGhostProps): ReactElement;
+
 type Box$2 = {
     x: number;
     y: number;
@@ -802,17 +993,21 @@ type SceneLike = {
         id: string;
         kind: 'mark' | 'group';
         data: unknown;
+        parent?: string | null;
     } | undefined;
 };
+/** Whether the nodes `ids` may move into the container or lane `container`. */
+type CanReparent = (ids: readonly string[], container: string) => DropVerdict;
 /**
  * The `canDropInto` dep for a diagram scene. A container or a lane takes
  * shapes and other containers, a pool takes only lanes, and a lane goes
  * nowhere but a pool. A stencil body, an edge, or a label takes nothing, and
  * edges and labels are never dropped in: they stay where they are, drawn from
  * what they are attached to. Any other container — a plain group — takes
- * anything but a lane.
+ * anything but a lane. `canReparent` is asked about a move the rules allow
+ * into a container the nodes are not already in, and has the last word.
  */
-declare function diagramCanDropInto(scene: SceneLike): (parent: string, ids: readonly string[]) => boolean;
+declare function diagramCanDropInto(scene: SceneLike, canReparent?: CanReparent): (parent: string, ids: readonly string[]) => DropVerdict;
 /** What {@link diagramDropParentAt} walks. */
 interface DropParentScene {
     readonly roots: readonly string[];
@@ -823,6 +1018,10 @@ interface DropParentScene {
         data: unknown;
         pose: unknown;
     } | undefined;
+    /** How a child's stored pose joins its parent's. Absent, poses are world poses. */
+    readonly composition?: {
+        compose(parent: never, child: never): unknown;
+    };
 }
 /**
  * The innermost container or lane whose body holds `point`, that would admit
@@ -834,13 +1033,6 @@ declare function diagramDropParentAt(scene: DropParentScene, point: {
     y: number;
 }, role: ContainerRole | null): string | null;
 
-/**
- * The lane affordances on every pool: the boundary after each lane, which a
- * drag moves to resize that lane, and the add-lane button past the end of the
- * stack. Built the way the edge-end handles are: regions with a `null`
- * `targetId`, composed into a layer whose id is the kind a press reports.
- */
-
 /** The layer id the lane affordances are composed into. */
 declare const LANE_LAYER_ID = "diagram-lanes";
 /** The affordance kind a press on a lane affordance reports. */
@@ -856,19 +1048,22 @@ interface LaneScratch {
 declare function laneScratchOf(hit: {
     payload?: unknown;
 } | null | undefined): LaneScratch | null;
-type AnyScene$2 = Scene<unknown, string, unknown>;
-/** A pool as the affordances see it: its box, the axis it stacks along, and its lanes in order. */
+type AnyScene$3 = 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 {
     id: string;
     axis: 'x' | 'y';
     pose: RectPose;
+    at: RectPose;
     lanes: {
         id: string;
         pose: RectPose;
+        at: RectPose;
     }[];
 }
 /** Every pool in `scene` that is drawn and not locked. */
-declare function poolsOf(scene: AnyScene$2): PoolLanes[];
+declare function poolsOf(scene: AnyScene$3): PoolLanes[];
 /** Options for {@link laneLayer}. */
 interface LaneLayerOptions {
     /** Screen-pixel reach of a boundary either side of it. Default 4. */
@@ -879,9 +1074,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$2, opts?: LaneLayerOptions): Affordance;
+declare function createLaneAffordance(scene: AnyScene$3, opts?: LaneLayerOptions): Affordance;
 /** The composed layer, for `CanvasExtensionApi.registerLayer`. */
-declare function laneLayer(scene: AnyScene$2, opts?: LaneLayerOptions): RenderLayer<unknown>;
+declare function laneLayer(scene: AnyScene$3, opts?: LaneLayerOptions): RenderLayer<unknown>;
 
 /**
  * The container actions: dragging the boundary after a lane resizes it, the
@@ -896,7 +1091,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$1 = Scene<unknown, string, unknown>;
+type AnyScene$2 = Scene<unknown, string, unknown>;
 /** A lane resized: its new size along its pool's stack. */
 interface LaneResize {
     poolId: string;
@@ -908,10 +1103,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$1, pool: PoolLanes, index: number, size: number): Map<string, RectPose>;
+declare function laneResizeFrame(scene: AnyScene$2, pool: PoolLanes, index: number, size: number): Map<string, RectPose>;
 /** Options for the container actions. */
 interface LaneActionOptions extends LaneLayerOptions {
-    scene: AnyScene$1;
+    scene: AnyScene$2;
     /** The selected ids, which Release members reads. */
     selected?: () => readonly string[];
     /** Defaults to {@link commitLaneResizeToScene}. */
@@ -1305,45 +1500,6 @@ declare function createRemoveWaypointAction<TPose>(opts: RouteEditOptions<TPose>
  *  in one history entry when they commit to the scene. */
 declare function createResetRouteAction<TPose>(opts: RouteEditOptions<TPose>): Action;
 
-/**
- * The commands that set the selected connectors' router: Around shapes,
- * Orthogonal, Straight, and Curved. Leaving `avoid` drops the stored route;
- * joining it leaves the route to the edit pass `useAvoidRouting` installs,
- * which routes the connectors in the same history entry.
- */
-
-/** The router commands' ids, by router key. */
-declare const SET_ROUTER_ACTION_IDS: {
-    readonly avoid: "diagram.router.avoid";
-    readonly orthogonal: "diagram.router.orthogonal";
-    readonly straight: "diagram.router.straight";
-    readonly bezier: "diagram.router.bezier";
-};
-/** Each shipped router's name in a menu. */
-declare const ROUTER_LABELS: Readonly<Record<keyof typeof SET_ROUTER_ACTION_IDS, string>>;
-/** One connector's router changed. */
-interface RouterEdit {
-    edgeId: string;
-    router: string;
-}
-/** Options for {@link createSetRouterAction}. */
-interface SetRouterOptions<TPose> {
-    participants: ParticipantSource<TPose>;
-    /** The selected ids; the connectors among them are set. */
-    selected: () => readonly string[];
-    /** Defaults to {@link commitRouterToScene} against `deps.scene`. */
-    commit?: (edit: RouterEdit, ctx: InvocationCtx) => void;
-}
-/** `data` with its edge trait on `router`, its stored route dropped. */
-declare function withRouter(data: unknown, trait: DiagramEdge, router: string): Record<string, unknown>;
-/** The default commit: the connector's `data.diagram.router`, written to the scene. */
-declare function commitRouterToScene(edit: RouterEdit, ctx: InvocationCtx): void;
-/** The command that puts the selected connectors on `router`, in one history
- *  entry. Active while every selected connector is on it already. */
-declare function createSetRouterAction<TPose>(router: keyof typeof SET_ROUTER_ACTION_IDS, opts: SetRouterOptions<TPose>): Action;
-/** One command per shipped router, in menu order. */
-declare function routerActions<TPose>(opts: SetRouterOptions<TPose>): Action[];
-
 /**
  * Waypoints ride along with a move: when a whole-node transform carries both
  * ends of an edge by the same offset, the edge's waypoints go with them.
@@ -1435,12 +1591,24 @@ declare const DIAGRAM_PASS_ORDER: {
  */
 declare function useAvoidRouting<TPose>(scene: Scene<unknown, string, TPose>, opts?: AvoidRoutingOptions<TPose>): void;
 
+/**
+ * Routes for a data-backed diagram: the specs `diagramScene` builds, with
+ * every edge routed around the shapes. The routes derive from the data, so
+ * they live in the specs and are never reported back to the host.
+ */
+
+/** How {@link createSpecRouter} routes: the router's own options, and the composition the specs' poses are stored
+ *  under, which must be the one `diagramScene` was given. Default {@link RIGID_POSE_COMPOSITION}, as there. */
+interface SpecRouterOptions extends AvoidOptions {
+    composition?: PoseComposition<RectPose>;
+}
 /**
  * A function from specs to the same specs with each edge on `avoid` and
  * holding its route. It holds one router across calls, so each call reroutes
- * only the edges the change since the last one disturbed.
+ * only the edges the change since the last one disturbed. Shapes and ports are
+ * read where they draw, each pose folded through the containers above it.
  */
-declare function createSpecRouter(options?: AvoidOptions): (specs: readonly DiagramSpec[]) => DiagramSpec[];
+declare function createSpecRouter(options?: SpecRouterOptions): (specs: readonly DiagramSpec[]) => DiagramSpec[];
 
 /**
  * A connector's route drawn with its hops: each one a half circle in place of
@@ -1568,26 +1736,28 @@ declare function diagramEdgeEnds<TPose>(opts: ReconnectOptions<TPose> & Omit<Edg
 };
 
 /**
- * Reordering a group marked `reorder`: a member dragged along that axis among
+ * Reordering a group or container marked `reorder`: a member dragged along that axis among
  * its siblings, which slide into the places they would take, or the selected
- * one stepped with Alt and an arrow key. Nothing is written: the host hears
+ * one stepped with Alt and an arrow key. A container's member dragged out of its box goes to the move instead. Nothing is written: the host hears
  * the new order, writes it to its data, and layout keeps it.
  */
 
 /** Alt and an arrow key: the selected member one place along. */
 declare const STEP_REORDER_ACTION_ID = "diagram.stepReorder";
-/** A reorderable group's members in their new order. */
+/** A reorderable group's or container's members in their new order. */
 interface ReorderChange {
-    group: string;
+    /** The group's or the container's id. */
+    parent: string;
     order: readonly string[];
 }
-/** The members of the reorderable group a press at `at` carries one of, each
- *  with everything drawn with it, or `null` off any such group. */
+/** The members of the reorderable group or container a press at `at` carries
+ *  one of, each with everything drawn with it, or `null` off any. */
 declare function groupReorderSlots(deps: ActionDeps, at: Vec2): ReorderSlots | null;
 /** Steps the selected node's member one place toward the start (`-1`) or the end (`1`). */
 declare function createStepReorderAction(report: (change: ReorderChange) => void): Action;
 /** Everything `DiagramView` installs for `onReorder`: the reorder drag,
- *  sliding, pressed on a node's body, and the step action. */
+ *  sliding, pressed on a node's body, and the step action. A container's member
+ *  dragged out of the container's box is handed to the move. */
 declare function groupReorderContribution(report: (change: ReorderChange) => void): Contribution;
 
 /** How a self-edge with no ports named leaves its node and comes back. */
@@ -1692,8 +1862,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>;
 /** The topmost draggable label whose box holds `at`, as its press scratch. */
-declare function labelUnder(scene: Scene<unknown, string, unknown>, at: Vec2$1): LabelScratch | null;
+declare function labelUnder(scene: AnyScene$1, 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. */
@@ -2278,13 +2449,14 @@ interface ApplyLayoutOptions<TPose> {
  * pose can be a path or anything else a consumer wired, and only its own
  * descriptor knows how to move one.
  *
- * A participant that is a container takes its whole subtree along. `setPose`
- * does not cascade — poses are absolute.
+ * A participant that is a container takes what its frame holds along.
  */
 declare function applyLayout<TPose>(scene: Scene<unknown, string, TPose>, result: LayoutResult, opts?: ApplyLayoutOptions<TPose>): number;
 /**
  * The poses a layout result implies, without writing any of them: each moved
- * node translated to its new top-left, and its subtree translated with it.
+ * node translated so its box starts where the layout put it, in world, and
+ * stored in its container's frame. What a moved container's frame holds rides
+ * it; a node under an envelope moved with it is written too.
  *
  * The translation is measured from the node's document pose, which a live run
  * in flight never changes, so a frame's answer does not depend on the frame
@@ -2310,6 +2482,17 @@ interface LayoutActionOptions<TPose> {
     read?: DiagramNodeReader;
     geometry?: PoseDescriptor<TPose>;
 }
+/** Options for {@link layoutDiagram}. */
+interface LayoutDiagramOptions<TPose> {
+    layout?: LayoutOptions;
+    read?: DiagramNodeReader;
+    geometry?: PoseDescriptor<TPose>;
+    /** The undo entry's name. Default `'Layout'`. */
+    label?: string;
+}
+/** Builds the graph `source` reads, runs `algorithm` on it — a key of {@link LAYOUTS} or a layout of
+ *  the caller's own — and writes the moves and routes as one undo entry. Returns how many nodes moved. */
+declare function layoutDiagram<TPose>(scene: Scene<unknown, string, TPose>, source: GraphSource<TPose>, algorithm: string | LayoutFn, opts?: LayoutDiagramOptions<TPose>): number;
 /**
  * `diagram.layout` — rebuild the graph, run a layout, write the result.
  */
@@ -2340,7 +2523,10 @@ interface ParticipantScene<TPose> {
         read(id: string): {
             pose?: TPose;
         } | undefined;
+        getGeneration?(): number;
     };
+    /** With `overrides.getGeneration`, what lets the port layer index the ports. */
+    getVersion?(): number;
     get(id: string): unknown;
     childrenOf(id: string): readonly string[];
 }
@@ -2351,15 +2537,17 @@ interface ParticipantScene<TPose> {
  * marks keep ports off such a node; the graph reads past them, so a hidden
  * node is still laid out.
  *
- * `effectivePose`, not `node.pose`: an override is what a gesture is currently
+ * Its effective pose, in world: an override is what a gesture is currently
  * showing, and a port that answers from the document pose while its node is
- * mid-drag sits somewhere the user can see the node is not.
+ * mid-drag, or from its pose in its container's frame, sits somewhere the
+ * user can see the node is not.
  *
- * One source answers both the ports and the graph.
+ * One source answers both the ports and the graph. A scene with versions
+ * gives it a `generation`, so the port layer hit-tests through an index.
  */
-declare function sceneParticipants<TPose>(scene: ParticipantScene<TPose>): () => Iterable<ParticipantPose<TPose> & {
+declare function sceneParticipants<TPose>(scene: ParticipantScene<TPose>): ParticipantSource<TPose> & (() => Iterable<ParticipantPose<TPose> & {
     node: GraphNodeLike;
-}>;
+}>);
 /**
  * The composed layer, ready for `CanvasExtensionApi.registerLayer` — the only
  * attach route that is hit-tested. Handing this to `SceneCanvas`'s `layers`
@@ -2428,11 +2616,6 @@ interface DiagramOverlay {
     content: ReactNode;
 }
 
-/**
- * The regions half of `DiagramView`'s sync: where each container, pool, and
- * lane stands, and the region edits a change to that is reported as.
- */
-
 type Box = {
     x: number;
     y: number;
@@ -2559,12 +2742,18 @@ interface DiagramViewProps {
      *  then needs a size of its own; a resize of the parent is a size change. */
     width?: number;
     height?: number;
-    /** A participant id, or null for none. */
-    selected?: string | null;
-    /** Reports what each click leaves picked, `null` for none — a re-click on the
+    /** `'multiple'` lets Shift-click add a node, group or edge to what is
+     *  picked, or take it out. Default `'single'`: every click picks one. */
+    selectionMode?: 'single' | 'multiple';
+    /** A participant id, a set of them, or null for none. One id under
+     *  `'multiple'` agrees with a pick of several whose latest it is, so handing
+     *  back what `onSelect` reports as `id` leaves the rest picked. */
+    selected?: string | null | readonly string[];
+    /** Reports what each click leaves picked: its latest pick, `null` for none,
+     *  and every id picked, in the order they were — a re-click on the
      *  picked node reports it again. The canvas keeps the pick even if
      *  `selected` does not follow it; only a change to `selected` is pushed in. */
-    onSelect?: (id: string | null) => void;
+    onSelect?: (id: string | null, ids: readonly string[]) => void;
     /** Reports the node, group or edge the pointer comes to be over, and `null`
      *  once it is over none or leaves the canvas. An edge answers only while
      *  edges are picked (`pickEdges`). */
@@ -2610,7 +2799,9 @@ interface DiagramViewProps {
     /** Set to let a member of a group marked `reorder` be dragged along that
      *  axis among its siblings, or the selected one stepped with Alt and an
      *  arrow key. Reports the members' new order and moves nothing: write it to
-     *  the group's `members`, which layered layout keeps. */
+     *  the group's `members`, which layered layout keeps. A container's member
+     *  dragged out of the container's box becomes a move, as `onMove` reports
+     *  one, and lands wherever it is dropped. */
     onReorder?: (change: ReorderChange) => void;
     /** Set to report a double-click on an edge, for its label to be edited. */
     onEditLabel?: (edge: string) => void;
@@ -2642,8 +2833,27 @@ interface DiagramViewProps {
      *  is set. */
     enableKeybindings?: boolean;
     /** Which ports may be joined. Default: a port may not join itself, and two
-     *  typed ports must share a type. */
+     *  typed ports must share a type. A refusal (`{ refuse }`) draws the port
+     *  refused with its reason beside the pointer; a connect or reconnect
+     *  released there reports nothing. */
     canConnect?: CanConnect;
+    /** Whether a drag may move nodes into a container or lane they are not in,
+     *  asked only of a move the diagram's own rules allow (a pool takes lanes, a
+     *  container takes shapes and containers). `false` passes the container
+     *  over, as if the drop were not on it; a refusal draws it refused with
+     *  its reason beside the pointer, and a release there moves nothing. */
+    canReparent?: CanReparent;
+    /** Set to take items carried in from outside the canvas, from an element
+     *  made a source with `dragItemProps(item)`. While one is over the canvas,
+     *  the shape or container it would land on is outlined, and in a container
+     *  marked `reorder`, a bar marks its place. Reports the item, what it was
+     *  dropped on, the container that would hold it, and its index among that
+     *  container's members; adds nothing. */
+    onDropItem?: (drop: ItemDrop) => void;
+    /** Whether a carried item may land where it is over. A refusal draws the
+     *  target refused with its reason beside the pointer, and a release there
+     *  reports nothing. Default: everywhere. */
+    canDropItem?: CanDropItem;
     /** How ports look and answer the pointer, and the router a connect's
      *  preview draws with. */
     portOptions?: Pick<DiagramContributionOptions<RectPose>, 'fill' | 'stroke' | 'shape' | 'sizePx' | 'hitRadiusPx' | 'cursor' | 'shows' | 'showsPort' | 'snapRadius' | 'router'>;
@@ -2663,6 +2873,14 @@ interface DiagramViewProps {
     /** Space kept clear around the diagram by the fit, in CSS pixels.
      *  Default 16. */
     fitPadding?: number;
+    /** Keep the view on the diagram: panning and zooming stop where the view would show more than
+     *  the diagram and `fitPadding` world units around it, and a view showing more than all of it
+     *  centers it. Unset, the plane pans without end. */
+    bounded?: boolean;
+    /** When new specs refit a view still on its last fit: only once they run past what it shows
+     *  (`'overflow'`, the default), or on every change (`'always'`), so the diagram stays fitted
+     *  as it grows and shrinks. A view panned or zoomed off its fit is never refitted. */
+    refit?: 'overflow' | 'always';
     /** What the canvas paints behind the diagram. Unset, it is transparent. */
     background?: Paint;
     /** Sheets painted under the diagram, one filled rect per page; `diagramPages(data)`
@@ -2727,9 +2945,12 @@ declare const DiagramView: react.ForwardRefExoticComponent<DiagramViewProps & re
 
 /** Keeps a canvas selection and a controlled `selected` prop in step: a prop
  *  change is pushed in, and every click reports what the selection holds after
- *  it — a re-click on the picked node included. Wire the returned handler to
- *  `<SceneCanvas onClick>`. */
-declare function useMirroredSelection(selection: Pick<SelectionApi, 'get' | 'set'>, selected: string | null | undefined, onSelect: ((id: string | null) => void) | undefined): () => void;
+ *  it — a re-click on the picked node included — as its latest pick and as
+ *  every id it holds, in the order they were picked. `selected` is one id, a set
+ *  of them, or null for none; one id agrees with a selection whose latest pick
+ *  it is, so reporting a pick back does not drop the rest of a set. Wire the
+ *  returned handler to `<SceneCanvas onClick>`. */
+declare function useMirroredSelection(selection: Pick<SelectionApi, 'get' | 'set'>, selected: string | null | readonly string[] | undefined, onSelect: ((id: string | null, ids: readonly string[]) => void) | undefined): () => void;
 
 /** The themes that ship, by id, in the order a picker lists them. `paper` is ink on white;
  *  `night` is the effect looks' own dark colors. */
@@ -2816,9 +3037,9 @@ declare const rendererMeasure: MeasureRowText;
 
 /**
  * Laying a built body out again once its text changes size. A body whose
- * rows are all text records how it stacks them (`DiagramNode.body`), and each
- * text row records its place (`bodyRow`), so the rows can be read back from
- * the scene and handed to the same layout `buildBody` used.
+ * rows are all text or dividers records how it stacks them (`DiagramNode.body`),
+ * and each text row records its place (`bodyRow`), so the rows can be read
+ * back from the scene and handed to the same layout `buildBody` used.
  */
 
 /** A scene as {@link relayoutBodies} reads and writes it. */
@@ -2829,6 +3050,7 @@ interface RelayoutScene {
     } | undefined;
     childrenOf(id: never): readonly string[];
     setPose(id: never, pose: never): void;
+    update(id: never, patch: never): void;
 }
 /**
  * Lays each body among `ids` out again from its text rows as they are now:
@@ -2943,4 +3165,106 @@ declare function parseDiagramTheme(json: string): {
     errors: string[];
 };
 
-export { ADD_LANE_ACTION_ID, type ApplyDiagramThemeOptions, type ApplyLayoutOptions, AvoidInput, AvoidOptions, AvoidRouter, AvoidRoutes, type AvoidRouting, type AvoidRoutingOptions, type AvoidSceneOptions, type BodyEnd, type BodyHit, Bounds$2 as Bounds, CONNECTOR_ACTION_ID, CONNECTOR_TOOL_ID, CONNECT_ACTION_ID, CONTAINER_HEADER, CONTAINER_LAYOUTS, CONTAINER_STENCILS, type CanConnect, 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_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, 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, 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, type EasedProducerOptions, EdgeEnd, type EdgeEndAffordanceOptions, type EdgeEndScratch, EdgeHop, type EdgeLabelOptions, type EdgeRoute, type EdgeRouteOptions, type EdgeRouteState, EdgeStyle, type EditEdgeLabelOptions, type EndChange, FLOWCHART_STENCILS, 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, 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, LayoutDirection, LayoutFn, LayoutOptions, LayoutPlan, LayoutPlanner, LayoutPorts, LayoutResult, type LayoutRoutes, type LiveLayout, type LiveLayoutCtx, type LiveLayoutFrame, type LiveLayoutProducer, MIN_LANE_SIZE, MOVE_LABEL_ACTION_ID, MeasureRowText, type MovingEnd, type NodeMove, type NodeResize, NodeStyle, OFF_PAGE_STUB, OFF_PAGE_TAG_DERIVE_POSE, OFF_PAGE_TAG_PADDING, 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, Row, RowTextStyle, SELECT_LABEL_EDGE_ACTION_ID, SET_HOPS_ACTION_ID, SET_ROUTER_ACTION_IDS, STEP_REORDER_ACTION_ID, type SelfLoop, type SetHopsOptions, type SetRouterOptions, type StencilInsertOptions, StyleField, type StyledRegion, type ThemePath, type ThemedNode, type ThemedScene, type UseLiveLayoutOptions, WAYPOINT_AFFORDANCE_KIND, WAYPOINT_HIT_PX, WAYPOINT_LAYER_ID, type WaypointAffordanceOptions, type WaypointScratch, addLane, addThemeRole, applyDiagramTheme, applyLayout, avoid, avoidSceneInput, bezier, bodyAt, commitEdgeToScene, commitLabelToScene, commitLaneResizeToScene, commitReconnectToScene, commitRouteToScene, commitRouterToScene, connectBinding, connectorTool, containerBuild, containerShape, createAddLaneAction, createConnectAction, createDiagramContribution, createEdgeEndAffordance, createFollowOffPageAction, 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, diagramWaypoints, documentBoundsOf, dragSegment, dragVertex, draggableLabels, dropEmptyEdgeLabel, easedProducer, edgeDerivePath, edgeEndLayer, edgeEndScratchOf, edgeIdOf, edgeLabelSpec, edgeRouter, editContainerTitleAction, editContainerTitleBinding, editEdgeLabelAction, editEdgeLabelBinding, editableTheme, firstLanes, followOffPageBinding, forceProducer, forkTheme, grabPortAction, grabPortBindings, groupReorderContribution, groupReorderSlots, headerIdOf, hopFollower, insertWaypoint, installAvoidRouting, installHops, installLabelPlacement, installOffPageMarkers, isBodyEnd, isBodyOrRegion, isDiagramBody, isShippedTheme, labelDerivePose, labelDragLayer, labelScratchOf, labelSize, labelUnder, laneHeader, laneLayer, laneResizeFrame, laneScratchOf, laneStackLayout, lanesOf, layeredRoutes, 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, removeThemeRole, removeWaypoint, renameThemeRole, rendererMeasure, reorderBinding, reorderContribution, resolveEnd, roleEdgeStyle, roleStyle, routeDataOps, routeHandles, routeStateOf, routeWrites, routedData, routerActions, routesOf, sceneParticipants, segmentAxis, selfLoop, sequenceSlots, setDiagramColor, setDiagramFontSize, setDiagramStyle, setThemeValue, simplifyStops, stackedLanes, 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 };
+/** The stencil groups this package ships, by id, in menu order. */
+declare const STENCIL_GROUPS: Readonly<Record<string, StencilGroup>>;
+/** The flowchart: its symbols and containers, connectors as the theme draws them, no auto layout. */
+declare const FLOWCHART_TYPE: DiagramType;
+/** A network: devices joined by plain straight links. */
+declare const NETWORK_TYPE: DiagramType;
+/** A BPMN process: sequence flows routed square, ending in an arrow. */
+declare const BPMN_TYPE: DiagramType;
+/** An org chart: cards joined by unmarked orthogonal connectors, laid out top-down as a tree. */
+declare const ORG_CHART_TYPE: DiagramType;
+/** A mind map: topics joined by unmarked curves, the central topic in the middle of a radial layout. */
+declare const MIND_MAP_TYPE: DiagramType;
+/** A UML class diagram: classes and their kin, connectors routed orthogonally to an open arrowhead. */
+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;
+/** 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. */
+declare const isContainerStencil: (stencil: DiagramStencil | ContainerStencil) => stencil is ContainerStencil;
+/** Every stencil of the groups `ids` names, in their order. An id `catalog` lacks adds nothing. */
+declare function groupStencils(ids: readonly string[], catalog?: Readonly<Record<string, StencilGroup>>): (DiagramStencil | ContainerStencil)[];
+/** The ids of `group`'s stencils. */
+declare const groupStencilIds: (group: StencilGroup) => string[];
+
+/** A scene as the type reader and writers use it. */
+interface DiagramTypeScene {
+    doc: {
+        get(key: string): unknown;
+        set(key: string, value: unknown): void;
+    };
+    batch<T>(label: string, fn: () => T): T;
+}
+type Types = Readonly<Record<string, DiagramType>>;
+/** Options for the diagram type writers. */
+interface DiagramTypeWriteOptions {
+    /** The catalog type ids resolve in. Default {@link DIAGRAM_TYPES}. */
+    types?: Types;
+    label?: string;
+}
+/** A new document's value for type `id`: it, and its groups. Flowchart for an id `types` lacks. */
+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;
+/** The type a scene holds, as {@link diagramTypeDocOf} reads it. */
+declare function diagramTypeOf(scene: Pick<DiagramTypeScene, 'doc'>, types?: Types): DiagramType;
+/** 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. */
+declare function addStencilGroup(scene: DiagramTypeScene, id: string, opts?: DiagramTypeWriteOptions): void;
+/** Stops showing stencil group `id`. Nothing when it is not shown. */
+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. */
+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. */
+declare const NETWORK_STENCILS: readonly DiagramStencil[];
+/** The network devices as a stencil group. */
+declare const NETWORK_GROUP: StencilGroup;
+
+/** BPMN's events, activities, gateways, and data. Pools come from the containers group. */
+declare const BPMN_STENCILS: readonly DiagramStencil[];
+/** The BPMN symbols as a stencil group. */
+declare const BPMN_GROUP: StencilGroup;
+
+/** People and the departments they sit in. */
+declare const ORG_STENCILS: readonly DiagramStencil[];
+/** The org chart cards as a stencil group. */
+declare const ORG_GROUP: StencilGroup;
+
+/** A mind map's topics, heaviest first, and a note to float beside them. */
+declare const MIND_MAP_STENCILS: readonly DiagramStencil[];
+/** The mind map topics as a stencil group. */
+declare const MIND_MAP_GROUP: StencilGroup;
+
+/**
+ * A resized body's rows go with it: a whole-node transform that changes a
+ * built body's size stacks its rows again inside the new box, the way
+ * `layoutBody` would, from the row heights its trait records.
+ */
+
+/**
+ * The transform follower that lays a resized body's rows out again, for the
+ * `transformFollowers` dep (`useTransformFollower`). A body saved before its
+ * row heights were recorded is left as it is. `geometry` reads a pose's
+ * bounds; default `AUTO_POSE_DESCRIPTOR`.
+ */
+declare function bodyFollower<TPose>(scene: Scene<unknown, string, TPose>, geometry?: PoseDescriptor<TPose>): TransformFollower;
+
+/** UML's class-diagram and use-case symbols. */
+declare const UML_STENCILS: readonly DiagramStencil[];
+/** The UML symbols as a stencil group. */
+declare const UML_GROUP: StencilGroup;
+
+/** An entity-relationship diagram's symbols: a crow's-foot entity table beside Chen's shapes. */
+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 };