@formicoidea/labre-core 0.41.0 → 0.42.0

package/dist/_pkgs/affine-model/elements/uml/fragment.js

@@ -0,0 +1,205 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { field } from '../../../std/gfx/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+import { umlInNameBand } from './band.js';
+/**
+ * Height of a combined fragment's OPERATOR BAND — the strip across its top the
+ * pentagon tag is drawn in, in model units.
+ *
+ * Owned by the model for the reason {@link UML_FRAME_BAND_HEIGHT} is: the
+ * fragment's own hit test reads it (a fragment is clickable by its tag strip as
+ * well as by its border), and `affine-model` cannot reach into
+ * `affine-block-surface` where the declaration is resolved.
+ *
+ * The diagram frame's own 44, and deliberately: §17.6.4 draws the operator in
+ * the very same cut-corner pentagon Annex A draws a frame heading in — it IS a
+ * frame, nested in another one — and two numbers for one piece of furniture
+ * would drift.
+ */
+export const UML_FRAGMENT_BAND = 44;
+/**
+ * A COMBINED FRAGMENT — the rectangle drawn round part of a sequence diagram
+ * with an operator in its corner (UML 2.5.1 §17.6.4), and, under the `ref`
+ * operator, the InteractionUse of §17.7.4.
+ *
+ * A framework background, and a TRANSPARENT one, like
+ * {@link UmlSubjectElementModel} and {@link UmlPartitionElementModel}: it is
+ * drawn OVER lifelines and messages that are already there, and an opaque card
+ * would hide the very conversation it is qualifying. Membership — which
+ * messages are inside the `alt`, which lifelines it covers — is geometry at
+ * read time (R11), never a stored list.
+ *
+ * ## Why the operator is a field and the operands are not elements
+ *
+ * The operator IS the fragment: `alt` and `loop` are the same rectangle saying
+ * two entirely different things, and nothing in the picture distinguishes them
+ * but the word. So it is stored, with `alt` as the default — the fragment an
+ * architect reaches for first, and the one §17.6.4 opens with.
+ *
+ * The operands are bands of that one rectangle, and they follow the BPMN pool's
+ * lanes exactly: an optional flat array, `undefined` rather than `[]` until the
+ * first one is added, so a fragment with a single operand stays byte-identical
+ * to one written before the field existed. The trade the pool's own note
+ * states applies here unchanged — two peers reordering the operands at the same
+ * moment resolve last-write-wins, one whole list winning over the other — and
+ * it is stated so it is reviewed rather than discovered.
+ *
+ * What it LOOKS like is declared, not coded: see `UML_FRAGMENT_FRAME` in
+ * `@labre/affine-gfx-uml`.
+ */
+let UmlFragmentElementModel = (() => {
+    let _classSuper = FrameworkBackgroundElementModel;
+    let _operator_decorators;
+    let _operator_initializers = [];
+    let _operator_extraInitializers = [];
+    let _name_decorators;
+    let _name_initializers = [];
+    let _name_extraInitializers = [];
+    let _resizeEnabled_decorators;
+    let _resizeEnabled_initializers = [];
+    let _resizeEnabled_extraInitializers = [];
+    let _rotate_decorators;
+    let _rotate_initializers = [];
+    let _rotate_extraInitializers = [];
+    let _xywh_decorators;
+    let _xywh_initializers = [];
+    let _xywh_extraInitializers = [];
+    let _operands_decorators;
+    let _operands_initializers = [];
+    let _operands_extraInitializers = [];
+    return class UmlFragmentElementModel extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _operator_decorators = [field('alt')];
+            _name_decorators = [field('')];
+            _resizeEnabled_decorators = [field(true)];
+            _rotate_decorators = [field(0)];
+            _xywh_decorators = [field()];
+            _operands_decorators = [field()];
+            __esDecorate(this, null, _operator_decorators, { kind: "accessor", name: "operator", static: false, private: false, access: { has: obj => "operator" in obj, get: obj => obj.operator, set: (obj, value) => { obj.operator = value; } }, metadata: _metadata }, _operator_initializers, _operator_extraInitializers);
+            __esDecorate(this, null, _name_decorators, { kind: "accessor", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
+            __esDecorate(this, null, _resizeEnabled_decorators, { kind: "accessor", name: "resizeEnabled", static: false, private: false, access: { has: obj => "resizeEnabled" in obj, get: obj => obj.resizeEnabled, set: (obj, value) => { obj.resizeEnabled = value; } }, metadata: _metadata }, _resizeEnabled_initializers, _resizeEnabled_extraInitializers);
+            __esDecorate(this, null, _rotate_decorators, { kind: "accessor", name: "rotate", static: false, private: false, access: { has: obj => "rotate" in obj, get: obj => obj.rotate, set: (obj, value) => { obj.rotate = value; } }, metadata: _metadata }, _rotate_initializers, _rotate_extraInitializers);
+            __esDecorate(this, null, _xywh_decorators, { kind: "accessor", name: "xywh", static: false, private: false, access: { has: obj => "xywh" in obj, get: obj => obj.xywh, set: (obj, value) => { obj.xywh = value; } }, metadata: _metadata }, _xywh_initializers, _xywh_extraInitializers);
+            __esDecorate(this, null, _operands_decorators, { kind: "accessor", name: "operands", static: false, private: false, access: { has: obj => "operands" in obj, get: obj => obj.operands, set: (obj, value) => { obj.operands = value; } }, metadata: _metadata }, _operands_initializers, _operands_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        get type() {
+            return 'umlFragment';
+        }
+        #operator_accessor_storage = __runInitializers(this, _operator_initializers, 'alt');
+        /**
+         * The operator — REQUIRED, with `alt` as the default, for the reason
+         * `UmlDiagramElementModel.kind` is required: it is part of the NOTATION
+         * rather than a claim an author may decline to make. A fragment with no
+         * operator has no word to write in its pentagon, and a pentagon with nothing
+         * in it is a rectangle with a bitten corner.
+         */
+        get operator() { return this.#operator_accessor_storage; }
+        set operator(value) { this.#operator_accessor_storage = value; }
+        #name_accessor_storage = (__runInitializers(this, _operator_extraInitializers), __runInitializers(this, _name_initializers, ''));
+        /**
+         * The first operand's guard, or — under `ref` — the name of the interaction
+         * being referred to.
+         *
+         * Seeded EMPTY, unlike every other UML frame's name: §17.6.4 draws a guard
+         * only where there is one to draw, and `[alt]` with an empty bracket under it
+         * would be the notation inventing a condition the author has not written. An
+         * empty string keeps the field in the document (the `@field` default is
+         * written) without putting words on the page.
+         */
+        get name() { return this.#name_accessor_storage; }
+        set name(value) { this.#name_accessor_storage = value; }
+        #resizeEnabled_accessor_storage = (__runInitializers(this, _name_extraInitializers), __runInitializers(this, _resizeEnabled_initializers, true));
+        get resizeEnabled() { return this.#resizeEnabled_accessor_storage; }
+        set resizeEnabled(value) { this.#resizeEnabled_accessor_storage = value; }
+        #rotate_accessor_storage = (__runInitializers(this, _resizeEnabled_extraInitializers), __runInitializers(this, _rotate_initializers, 0));
+        get rotate() { return this.#rotate_accessor_storage; }
+        set rotate(value) { this.#rotate_accessor_storage = value; }
+        #xywh_accessor_storage = (__runInitializers(this, _rotate_extraInitializers), __runInitializers(this, _xywh_initializers, '[0,0,600,260]'));
+        /**
+         * Wide enough to cover three lifelines at the 200-unit spacing a sequence
+         * diagram is laid out on, and tall enough for three or four exchanges — the
+         * size an `alt` is actually drawn round.
+         */
+        get xywh() { return this.#xywh_accessor_storage; }
+        set xywh(value) { this.#xywh_accessor_storage = value; }
+        #operands_accessor_storage = (__runInitializers(this, _xywh_extraInitializers), __runInitializers(this, _operands_initializers, undefined));
+        /**
+         * The fragment's partition into operands, top to bottom.
+         *
+         * `undefined`, not `[]`, and for the three reasons `BpmnPoolElementModel
+         * .lanes` states in full: `@field()` writes nothing for an undefined default,
+         * so a fragment with a single operand — which is every `opt`, every `loop`
+         * and every `ref` — is byte-identical to one created before this field
+         * existed; the value is flat JSON because a list of operands is one atomic
+         * choice about how one fragment is cut; and it is declared here rather than
+         * on the base class because an operand is a subdivision of a combined
+         * fragment and of nothing else.
+         *
+         * What it MEANS is declared, not coded: `UML_FRAGMENT_FRAME.instanceZones`
+         * in `@labre/affine-gfx-uml` names this prop, and the framework-background
+         * primitive paints the separators and the guards from it.
+         */
+        get operands() { return this.#operands_accessor_storage; }
+        set operands(value) { this.#operands_accessor_storage = value; }
+        /**
+         * Picked by its BORDER — and by its OPERATOR BAND, the one carve-out it
+         * keeps.
+         *
+         * The same carve-out the diagram frame, the partition and the composite state
+         * all make, and for the same reason: the band is the only part of the
+         * fragment that is the FRAGMENT rather than the conversation drawn inside it.
+         * Without it the pentagon would be unreachable, a background being picked by
+         * its border alone — and a transparent fragment's border is a thin line round
+         * a region full of other people's messages.
+         *
+         * Nothing below the band is claimed, which matters here as much as on a
+         * partition: a fragment is drawn OVER lifelines, so every point that is not
+         * its own furniture has to fall through to whatever is under the pointer.
+         */
+        includesPoint(x, y, options) {
+            if (super.includesPoint(x, y, options))
+                return true;
+            return umlInNameBand(this, 'top', UML_FRAGMENT_BAND, x, y);
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _operands_extraInitializers);
+        }
+    };
+})();
+export { UmlFragmentElementModel };

package/dist/_pkgs/affine-model/elements/uml/index.d.ts

@@ -0,0 +1,8 @@
+export * from './band.js';
+export * from './diagram.js';
+export * from './fragment.js';
+export * from './lifeline.js';
+export * from './node.js';
+export * from './partition.js';
+export * from './region.js';
+export * from './subject.js';

package/dist/_pkgs/affine-model/elements/uml/index.js

@@ -0,0 +1,8 @@
+export * from './band.js';
+export * from './diagram.js';
+export * from './fragment.js';
+export * from './lifeline.js';
+export * from './node.js';
+export * from './partition.js';
+export * from './region.js';
+export * from './subject.js';

package/dist/_pkgs/affine-model/elements/uml/lifeline.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The LIFELINE's geometry — the two numbers a lifeline is drawn, selected and
+ * hit-tested from (UML 2.5.1 §17.3.4).
+ *
+ * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-uml`, for
+ * the reason {@link UML_FRAME_BAND_HEIGHT} and {@link UML_PARTITION_BAND} are:
+ * the element's own `elementBound` and `includesPoint` read them (a lifeline's
+ * HEAD overflows the column the element actually is), and `affine-model` cannot
+ * reach into the package where the renderer lives. One pair of numbers, owned by
+ * the layer that the model, the renderer and the label layout can all read.
+ *
+ * ## Why a lifeline is a narrow column and not a head-shaped box
+ *
+ * §17.3.4 draws a lifeline as a named rectangle with a dashed vertical line
+ * falling out of its bottom edge, down the whole height of the interaction. The
+ * thing a message ATTACHES to is that line, never the rectangle — so the element
+ * is the COLUMN (16 wide, {@link UML_LIFELINE_SPINE} tall), whose native
+ * perimeter puts every connector anchor on the spine's own x, and the head is
+ * painted over its top by the glyph layer.
+ *
+ * The consequence is the one thing this module exists to fix: the head is 160
+ * wide against a 16-wide element, so it hangs 72 units off each side of the box
+ * the platform knows about. Selection, hit testing and frame fitting would all
+ * stop at the column — a user would see a named box and be unable to click it.
+ * {@link umlLifelineHeadRect} is the shared answer, read by the model's two
+ * overrides and by the renderer alike.
+ */
+export declare const UML_LIFELINE_HEAD: {
+    readonly w: 160;
+    readonly h: 48;
+};
+/**
+ * How tall a fresh lifeline's COLUMN is — the head plus the dashed spine under
+ * it, in model units.
+ *
+ * 600 is a sheet's worth of conversation: at the 40-unit rhythm a sequence
+ * diagram's messages are drawn on, it holds a dozen or so exchanges before the
+ * author has to drag it longer. Which is the resize a lifeline ever WANTS — the
+ * column is only ever wanted taller. It is not the only resize it accepts:
+ * nothing constrains the handles, and a wider column simply widens the painted
+ * head, which {@link umlLifelineHeadRect} sizes at `max(160, w)`.
+ */
+export declare const UML_LIFELINE_SPINE = 600;
+/** What a lifeline geometry question needs of an element: its box. */
+export interface UmlLifelineGeometry {
+    deserializedXYWH: readonly number[];
+    rotate?: number;
+}
+/** A rectangle in the element's own (unrotated) local frame. */
+export interface UmlLifelineRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/**
+ * The head box, in ELEMENT-LOCAL model units — the named rectangle §17.3.4
+ * draws at the top of the lifeline, centred on the column and flush with its
+ * top.
+ *
+ * `null` when there is nothing to draw: a column dragged to nothing.
+ *
+ * Never NARROWER than the column: a lifeline dragged wider than 160 units is a
+ * lifeline whose head is the whole of it, which is the only reading that keeps
+ * the head a box round the spine rather than a stripe down the middle of one.
+ * Clamped in height for the same reason the frame's heading band is — a column
+ * shorter than its own head keeps a head, cut down to what there is.
+ */
+export declare function umlLifelineHeadRect(model: UmlLifelineGeometry): UmlLifelineRect | null;
+/**
+ * Whether a CANVAS point lies in the lifeline's head.
+ *
+ * The rotation is undone about the element's centre before anything is
+ * measured, exactly as {@link umlInNameBand} does it: the head is axis-aligned
+ * INSIDE the lifeline, never on the canvas.
+ */
+export declare function umlInLifelineHead(model: UmlLifelineGeometry, x: number, y: number): boolean;

package/dist/_pkgs/affine-model/elements/uml/lifeline.js

@@ -0,0 +1,89 @@
+import { rotatePoint } from '../../../global/gfx/index.js';
+/**
+ * The LIFELINE's geometry — the two numbers a lifeline is drawn, selected and
+ * hit-tested from (UML 2.5.1 §17.3.4).
+ *
+ * Declared HERE, in the model, and re-exported by `@labre/affine-gfx-uml`, for
+ * the reason {@link UML_FRAME_BAND_HEIGHT} and {@link UML_PARTITION_BAND} are:
+ * the element's own `elementBound` and `includesPoint` read them (a lifeline's
+ * HEAD overflows the column the element actually is), and `affine-model` cannot
+ * reach into the package where the renderer lives. One pair of numbers, owned by
+ * the layer that the model, the renderer and the label layout can all read.
+ *
+ * ## Why a lifeline is a narrow column and not a head-shaped box
+ *
+ * §17.3.4 draws a lifeline as a named rectangle with a dashed vertical line
+ * falling out of its bottom edge, down the whole height of the interaction. The
+ * thing a message ATTACHES to is that line, never the rectangle — so the element
+ * is the COLUMN (16 wide, {@link UML_LIFELINE_SPINE} tall), whose native
+ * perimeter puts every connector anchor on the spine's own x, and the head is
+ * painted over its top by the glyph layer.
+ *
+ * The consequence is the one thing this module exists to fix: the head is 160
+ * wide against a 16-wide element, so it hangs 72 units off each side of the box
+ * the platform knows about. Selection, hit testing and frame fitting would all
+ * stop at the column — a user would see a named box and be unable to click it.
+ * {@link umlLifelineHeadRect} is the shared answer, read by the model's two
+ * overrides and by the renderer alike.
+ */
+export const UML_LIFELINE_HEAD = { w: 160, h: 48 };
+/**
+ * How tall a fresh lifeline's COLUMN is — the head plus the dashed spine under
+ * it, in model units.
+ *
+ * 600 is a sheet's worth of conversation: at the 40-unit rhythm a sequence
+ * diagram's messages are drawn on, it holds a dozen or so exchanges before the
+ * author has to drag it longer. Which is the resize a lifeline ever WANTS — the
+ * column is only ever wanted taller. It is not the only resize it accepts:
+ * nothing constrains the handles, and a wider column simply widens the painted
+ * head, which {@link umlLifelineHeadRect} sizes at `max(160, w)`.
+ */
+export const UML_LIFELINE_SPINE = 600;
+/**
+ * The head box, in ELEMENT-LOCAL model units — the named rectangle §17.3.4
+ * draws at the top of the lifeline, centred on the column and flush with its
+ * top.
+ *
+ * `null` when there is nothing to draw: a column dragged to nothing.
+ *
+ * Never NARROWER than the column: a lifeline dragged wider than 160 units is a
+ * lifeline whose head is the whole of it, which is the only reading that keeps
+ * the head a box round the spine rather than a stripe down the middle of one.
+ * Clamped in height for the same reason the frame's heading band is — a column
+ * shorter than its own head keeps a head, cut down to what there is.
+ */
+export function umlLifelineHeadRect(model) {
+    const [, , w, h] = model.deserializedXYWH;
+    if (!(w > 0) || !(h > 0))
+        return null;
+    const width = Math.max(UML_LIFELINE_HEAD.w, w);
+    const height = Math.min(UML_LIFELINE_HEAD.h, h);
+    if (!(width > 0) || !(height > 0))
+        return null;
+    return { x: (w - width) / 2, y: 0, w: width, h: height };
+}
+/**
+ * Whether a CANVAS point lies in the lifeline's head.
+ *
+ * The rotation is undone about the element's centre before anything is
+ * measured, exactly as {@link umlInNameBand} does it: the head is axis-aligned
+ * INSIDE the lifeline, never on the canvas.
+ */
+export function umlInLifelineHead(model, x, y) {
+    const head = umlLifelineHeadRect(model);
+    if (!head)
+        return false;
+    const [ex, ey, w, h] = model.deserializedXYWH;
+    let lx = x - ex;
+    let ly = y - ey;
+    const rotate = model.rotate ?? 0;
+    if (rotate) {
+        const [ux, uy] = rotatePoint([x, y], [ex + w / 2, ey + h / 2], -rotate);
+        lx = ux - ex;
+        ly = uy - ey;
+    }
+    return (lx >= head.x &&
+        lx <= head.x + head.w &&
+        ly >= head.y &&
+        ly <= head.y + head.h);
+}

package/dist/_pkgs/affine-model/elements/uml/node.d.ts

@@ -0,0 +1,142 @@
+import { Bound } from '../../../global/gfx/index.js';
+import type { PointTestOptions } from '../../../std/gfx/index.js';
+import { ShapeElementModel } from '../shape/index.js';
+/**
+ * The UML artefacts the pack draws. Each maps onto a native shape, decorated by
+ * a glyph where the notation asks for one:
+ *
+ *  - classifiers  — `class`, `interface` and `enumeration`, the compartmented
+ *    rectangle of UML 2.5.1 §11.4, distinguished by the keyword above the name;
+ *  - instances    — `object`, the same rectangle with an underlined
+ *    `name : Type` (§11.6);
+ *  - containers   — `package`, the tabbed folder (§12.2);
+ *  - annotations  — `note`, the folded-corner rectangle of Annex A;
+ *  - use cases    — `actor`, the stick figure, and `use-case`, the ellipse
+ *    (§18.1);
+ *  - components   — `component`, the rectangle with the two-tabbed icon in its
+ *    corner (§11.6.4), its `port` (§11.3.4), and the two interface glyphs that
+ *    hang off it: `provided-interface`, the lollipop, and `required-interface`,
+ *    the socket (§10.4.4);
+ *  - deployments  — `artifact`, the document icon (§19.3.4), and the three
+ *    cubes: `node`, `device` and `execution-environment` (§19.4.4);
+ *  - activities   — `action`, the round-cornered rectangle of §15.3.4, the five
+ *    control nodes that route its flow (`initial`, `activity-final`,
+ *    `flow-final`, `decision`, `fork`), the `object-node` of §15.4.4 and the
+ *    three signal and event shapes of §16.3.4 / §16.10.4 (`send-signal`,
+ *    `accept-event`, `time-event`);
+ *  - state machines — `state` and `final-state` (§14.2.4), and the seven
+ *    pseudostates that route transitions: `choice`, `junction`,
+ *    `shallow-history`, `deep-history`, `entry-point`, `exit-point` and
+ *    `terminate`;
+ *  - interactions — `lifeline`, the named head over a dashed spine (§17.3.4),
+ *    the `execution` bar that sits on it (§17.2.4) and the `destruction` X that
+ *    ends it.
+ *
+ * ## Compatibility
+ *
+ * This union is only ever WIDENED — appended to, never reordered — and it is
+ * widened with new VALUES of the existing `kind` string field: no new field, no
+ * schema change, no migration and no backfill. The same promise `C4NodeKind`
+ * and `BpmnNodeKind` make: a diagram drawn today carries one of the values
+ * below, loads unchanged on a build that ships more of them, and paints exactly
+ * as it always did.
+ *
+ * What an OLDER build does with a kind it has never heard of is the other half
+ * of that promise: the element is a native shape, so it still paints its own
+ * box, its own colours and its own words — it simply gets no glyph, because the
+ * renderer draws pictures for the kinds it knows and nothing for the rest.
+ *
+ * The phases that widen it are named in ADR 0017: phase 1 drew the first eight,
+ * phase 2 appended the eight structural ones below them and then the nineteen
+ * behaviour ones below those, and lifelines come in phase 3.
+ */
+export type UmlNodeKind = 'class' | 'interface' | 'enumeration' | 'object' | 'package' | 'note' | 'actor' | 'use-case' | 'component' | 'port' | 'provided-interface' | 'required-interface' | 'artifact' | 'node' | 'device' | 'execution-environment' | 'action' | 'initial' | 'activity-final' | 'flow-final' | 'decision' | 'fork' | 'object-node' | 'send-signal' | 'accept-event' | 'time-event' | 'state' | 'final-state' | 'choice' | 'junction' | 'shallow-history' | 'deep-history' | 'entry-point' | 'exit-point' | 'terminate' | 'lifeline' | 'execution' | 'destruction';
+/**
+ * A UML node. Extends {@link ShapeElementModel} (a native shape) so it inherits
+ * ALL shape behaviour — editable stroke width / colours, inner text, native
+ * resize, the shape context toolbar — for free. `kind` discriminates the
+ * artefacts and drives the RENDERING alone; what a node MEANS is the `role`
+ * stamped on it at creation (`gfx/uml/src/roles.ts`).
+ *
+ * Mirrors {@link C4NodeElementModel}.
+ */
+export declare class UmlNodeElementModel extends ShapeElementModel {
+    get type(): string;
+    /**
+     * Connector anchors are restricted to the centre, as they are for a C4 node
+     * and for a BPMN flow object: a UML relationship attaches to the node centre
+     * and clips at the perimeter, so an association between two classifiers
+     * points at the classifiers rather than at whichever of their twelve anchors
+     * the hand was nearest.
+     *
+     * ONE kind says otherwise, and the notation is why. A message in a sequence
+     * diagram attaches at a HEIGHT on its lifeline's spine — that height is WHEN
+     * it happens, and it is the whole of what a sequence diagram says (§17.4.4).
+     * Snapping every message to a 600-unit column's centre would stack the entire
+     * conversation on one horizontal line. So a `lifeline` keeps its native
+     * perimeter anchors, which lie on the column's left and right edges, 8 units
+     * either side of the spine: exactly where every UML tool draws them.
+     */
+    get centerAnchorOnly(): boolean;
+    /**
+     * A lifeline's bound includes its HEAD; every other kind's is its box.
+     *
+     * §17.3.4 draws a lifeline as a named rectangle with a dashed line falling
+     * out of its bottom, and the element is the COLUMN the line runs down — 16
+     * units wide, so that a connector's native anchors land on the spine rather
+     * than 80 units off it. The head is 160 wide, so it hangs 72 units off each
+     * side of the element the platform knows about.
+     *
+     * Everything that measures an element measures `elementBound`: the selection
+     * rectangle, the marquee, "fit to frame", the group's own box. Without this
+     * override all of them would stop at the column, and a user would see a named
+     * box with a selection outline drawn down the middle of it.
+     *
+     * Nothing here is stored — it is derived from the element's own geometry — so
+     * it applies to a lifeline drawn before the override existed as well as
+     * after.
+     */
+    get elementBound(): Bound;
+    /**
+     * A UML node is SOLID whatever its `filled` flag says.
+     *
+     * `rect.includesPoint` (and `ellipse`'s) skips the interior test for an
+     * unfilled shape and falls back to the stroke plus the tight bounding box of
+     * the text run — the behaviour that makes a hollow group let clicks through
+     * to the work it encloses. Several UML kinds are created unfilled and
+     * unstroked on purpose: a `package` is a tabbed folder, a `note` a rectangle
+     * with a folded corner, an `actor` a stick figure, none of which a native
+     * rect can be, so the GLYPH paints the body and the native shape paints
+     * nothing at all.
+     *
+     * The consequence, the one the PO reported against C4 on 27/08/2026, is that
+     * such nodes cannot be double-clicked into their own text editor: the body a
+     * user can plainly see is not a hit target, and only the border and the
+     * handful of characters of the label are. Pointer events reach an element
+     * view through this method (`GfxViewEventHandler`), so selecting, hovering,
+     * dragging and `dblclick` are all affected — the last one visibly.
+     *
+     * Forcing `ignoreTransparent: false` says the one thing that is true of every
+     * UML artefact: it is a BOX, and its whole area belongs to it. Nothing here
+     * is stored — the override changes hit testing, never the document — so it
+     * applies to nodes drawn before it existed as well as after.
+     */
+    includesPoint(x: number, y: number, options: PointTestOptions): boolean;
+    /**
+     * The one field a UML node carries, and the whole of its schema.
+     *
+     * The labels a classifier shows — its name, its attribute compartment, its
+     * operation compartment — are deliberately NOT fields here. They are canvas
+     * TEXT elements, grouped with the shape, and they are edited in place exactly
+     * like any other words on the canvas (R16, and the PO recette of 28/08/2026
+     * that settled it for C4's type line and description). A field would have
+     * been a second place to write the same sentence, reachable only through a
+     * form, and the form is the mechanism the recette rejected: an architect
+     * writes on the picture.
+     *
+     * What that buys the document format is that this model stays exactly what it
+     * is — `kind`, on a native shape — however many compartments the component
+     * grows.
+     */
+    accessor kind: UmlNodeKind;
+}