@focus.matters/diagrams 0.1.2 → 0.2.1

package/dist/src/Diagrams/components/objects/RenderEdge/EdgeMidpoints.d.ts

@@ -1,11 +1,12 @@
 import { default as React } from 'react';
+import { Edge } from '../../../store/elements/Edge';
 import { Coordinates } from '../../../store/primitives/Coordinates';
 import { Midpoint } from './types';
-import { Edge } from '../../../store/elements/Edge';
 interface EdgeMidpointsProps {
     edge: Edge;
     onMouseDown: (m: Midpoint, ev: React.MouseEvent) => unknown;
     points: Coordinates[];
 }
+/** Renders draggable midpoint handles and edge-debug actions for every visible segment. */
 export declare const EdgeMidpoints: React.FC<EdgeMidpointsProps>;
 export {};

package/dist/src/Diagrams/context-menu/buildDiagramContextMenu.d.ts

@@ -1,5 +1,6 @@
 import { Diagram } from '../store/Diagram';
 import { ContextMenuElement } from './types';
+/** Builds a context menu whose editing actions respect the diagram's current rules. */
 export declare function buildDiagramContextMenu(diagram: Diagram, target: HTMLElement, cursor: {
     x: number;
     y: number;

package/dist/src/Diagrams/custom/bpmn/config/BPMNLabels.d.ts

@@ -3,7 +3,7 @@ export type BPMNLabels = {
     elements: Record<string, string>;
     eventOptions: Record<"none" | "start" | "intermediate" | "end" | "catch" | "throw", string>;
     actions: Record<"transform" | "connect" | "settings" | "close" | "delete" | "reverseDirection" | "resize" | "resizeElement", string>;
-    properties: Record<"title" | "name" | "type" | "condition" | "defaultFlow" | "directed" | "edgeType" | "routingType" | "eventType" | "eventStage" | "eventDirection" | "interrupting" | "subprocessStart" | "eventSubprocessStartType" | "loop" | "multiInstance", string>;
+    properties: Record<"title" | "name" | "type" | "condition" | "defaultFlow" | "directed" | "edgeType" | "routingType" | "eventType" | "eventStage" | "eventDirection" | "interrupting" | "subprocessStart" | "eventSubprocessStartType" | "loop" | "multiInstance" | "compensation" | "adHoc" | "transaction", string>;
     edges: Record<string, string>;
     routing: Record<"orthogonal" | "straight" | "curved", string>;
     inputs: Record<"blackBoxPoolName" | "documentAnnotationText" | "elementSearch" | "laneName", string>;

package/dist/src/Diagrams/custom/bpmn/extensions/BPMNModelerExtension.d.ts

@@ -15,7 +15,14 @@ export declare class BPMNModelerExtension extends DiagramExtension {
     RenderDiagram: (({ diagram, extension }: import('../../../store/extensions/DiagramExtension').TDiagramExtensionRenderProps<BPMNModelerExtension>) => import("react").JSX.Element | null) & {
         displayName: string;
     };
-    RenderUI: (({ diagram, extension }: import('../../../store/extensions/DiagramExtension').TDiagramExtensionRenderProps<BPMNModelerExtension>) => import("react").JSX.Element) & {
+    RenderUI: (({ diagram, extension, sections }: import('../../../store/extensions/DiagramExtension').TDiagramExtensionRenderProps<BPMNModelerExtension> & {
+        sections?: {
+            generalTitle: string;
+            additionalTitle: string;
+            additionalContent: import('react').ReactNode;
+            additionalEditable?: boolean;
+        };
+    }) => import("react").JSX.Element) & {
         displayName: string;
     };
     private labelConfiguration;
@@ -70,6 +77,12 @@ export declare class BPMNModelerExtension extends DiagramExtension {
     changeTaskMultiInstance(node: TaskNode, multiInstance: TaskMultiInstance): boolean;
     /** Toggles a task's standard conditional loop and records the property change. */
     changeTaskLoop(node: TaskNode, loop: boolean): boolean;
+    /** Toggles the BPMN compensation marker while recording one property mutation. */
+    changeTaskCompensation(node: TaskNode, compensation: boolean): boolean;
+    /** Toggles a standard sub-process ad-hoc marker and records one property mutation. */
+    changeTaskAdHoc(node: TaskNode, adHoc: boolean): boolean;
+    /** Toggles standard BPMN transaction notation and records one editable property mutation. */
+    changeTaskTransaction(node: TaskNode, transaction: boolean): boolean;
     /** Updates a selected edge label and records the mutation in diagram history. */
     renameEdge(edge: Edge, label: string): void;
     /** Returns only edge kinds that preserve all endpoint-specific BPMN constraints. */

package/dist/src/Diagrams/custom/bpmn/nodes/BPMNEventDefinition.d.ts

@@ -13,10 +13,19 @@ export declare enum EventTypes {
     errorCatch = 10,
     errorThrow = 11,
     conditional = 12,
-    terminate = 13
+    terminate = 13,
+    cancelCatch = 14,
+    cancelThrow = 15,
+    escalationCatch = 16,
+    escalationThrow = 17,
+    linkCatch = 18,
+    linkThrow = 19,
+    multipleCatch = 20,
+    multipleThrow = 21,
+    parallelMultiple = 22
 }
 export type EventStage = "start" | "intermediate" | "end";
-export type EventKind = "none" | "timer" | "message" | "signal" | "compensation" | "error" | "conditional" | "terminate";
+export type EventKind = "none" | "timer" | "message" | "signal" | "compensation" | "error" | "conditional" | "cancel" | "escalation" | "link" | "multiple" | "parallelMultiple" | "terminate";
 export type EventDirection = "catch" | "throw";
 export type EventDefinition = Readonly<{
     stage: EventStage;

package/dist/src/Diagrams/custom/bpmn/nodes/DocumentNode.d.ts

@@ -2,12 +2,86 @@ import { Element } from '../../../store/elements/Element';
 import { TNodeConstructorProps } from '../../../store/elements/Node';
 import { Dimensions } from '../../../store/primitives/Dimensions';
 import { BPMNode } from './BPMNode';
+/** Enumerates standard BPMN data-object states while retaining normal documents by default. */
+export declare enum DataObjectTypes {
+    normal = 0,
+    input = 1,
+    output = 2
+}
+type TDocumentNodeState = TNodeConstructorProps & {
+    type?: DataObjectTypes;
+};
 /** Models a transient BPMN data document connected through directional associations. */
 export declare class DocumentNode extends BPMNode {
+    type: DataObjectTypes;
     requiredEdgePathType: "straight";
-    constructor(parent: Element | null, state: TNodeConstructorProps);
+    protected occupiesGridSquare: boolean;
+    constructor(parent: Element | null, state: TDocumentNodeState);
+    /** Changes the BPMN data-object state while retaining its node geometry and connections. */
+    setType(type: DataObjectTypes): boolean;
+    /** Serializes the semantic data-object state alongside normal BPMN document state. */
+    serialize(): {
+        type: DataObjectTypes;
+        box: [number, number, number, number];
+        id: string;
+        label: string;
+        movable: boolean | undefined;
+        selectable: boolean | undefined;
+        selected: boolean | undefined;
+        gateways: {
+            coordinates: [number, number];
+            fill: string | undefined;
+            id: string;
+            orientation: import('../../../store/types').TOrientation;
+            radius: number;
+            stroke: string | undefined;
+            strokeWidth: number;
+            outEdges: {
+                arrowHeadEnd: import('../../../store/types').EdgeArrowHead | undefined;
+                arrowHeadStart: import('../../../store/types').EdgeArrowHead | undefined;
+                displacementEnd: [number, number] | undefined;
+                displacementStart: [number, number] | undefined;
+                lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+                stroke: string | undefined;
+                strokeWidth: number | undefined;
+                to: string;
+                toParentId: string;
+                class: string;
+            }[];
+            class: string;
+        }[];
+        fill: string | undefined;
+        labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Restores the persisted data-object state while accepting older normal documents. */
+    deserialize(o: ReturnType<this["serialize"]>): void;
     protected get screenLabelBox(): Dimensions;
     RenderOverlay: (() => import("react").JSX.Element) & {
         displayName: string;
     };
 }
+export {};

package/dist/src/Diagrams/custom/bpmn/nodes/GateNode.d.ts

@@ -6,7 +6,8 @@ export declare enum GateTypes {
     inclusive = 0,
     exclusive = 1,
     parallel = 2,
-    eventBased = 3
+    eventBased = 3,
+    complex = 4
 }
 /** Models fixed-grid BPMN gateways and their mutually exclusive marker variants. */
 export declare class GateNode extends BPMNode {

package/dist/src/Diagrams/custom/bpmn/nodes/TaskNode.d.ts

@@ -22,6 +22,9 @@ type TTaskNodeState = TNodeConstructorProps & {
     type?: TaskTypes;
     multiInstance?: TaskMultiInstance;
     loop?: boolean;
+    compensation?: boolean;
+    adHoc?: boolean;
+    transaction?: boolean;
 };
 /** Models BPMN activities with compact default geometry and selectable task variants. */
 export declare class TaskNode extends BPMNode implements BPMNResizableNode {
@@ -29,6 +32,9 @@ export declare class TaskNode extends BPMNode implements BPMNResizableNode {
     readonly minimumResizeSize: Coordinates;
     multiInstance: TaskMultiInstance;
     loop: boolean;
+    compensation: boolean;
+    adHoc: boolean;
+    transaction: boolean;
     edgesAsGateways: boolean;
     constructor(parent: Element | null, state: TTaskNodeState);
     private fitWidthToGrid;
@@ -41,11 +47,20 @@ export declare class TaskNode extends BPMNode implements BPMNResizableNode {
     setMultiInstance(multiInstance: TaskMultiInstance): boolean;
     /** Toggles the standard conditional-loop marker independently of other markers. */
     setLoop(loop: boolean): boolean;
+    /** Toggles the BPMN compensation marker independently from loop and multi-instance state. */
+    setCompensation(compensation: boolean): boolean;
+    /** Toggles the BPMN ad-hoc marker only when this node is a standard sub-process. */
+    setAdHoc(adHoc: boolean): boolean;
+    /** Toggles transaction notation only for BPMN sub-processes and call activities. */
+    setTransaction(transaction: boolean): boolean;
     /** Serializes the task subtype together with the shared editable node state. */
     serialize(): {
         type: TaskTypes;
         multiInstance: TaskMultiInstance;
         loop: boolean;
+        compensation: boolean;
+        adHoc: boolean;
+        transaction: boolean;
         box: [number, number, number, number];
         id: string;
         label: string;
@@ -104,6 +119,7 @@ export declare class TaskNode extends BPMNode implements BPMNResizableNode {
     /** Restores persisted task variants and defaults missing marker state safely. */
     deserialize(o: ReturnType<this["serialize"]>): void;
     protected get screenLabelBox(): Dimensions;
+    private refreshTransactionPresentation;
     RenderScreen: (() => import("react").JSX.Element) & {
         displayName: string;
     };

package/dist/src/Diagrams/custom/bpmn/ui/BPMNElementMenu.d.ts

@@ -1,11 +1,12 @@
 import { BPMNElementDefinition, BPMNElementId } from '../config/BPMNElementCatalog';
 import { BPMNLabels } from '../config/BPMNLabels';
 type BPMNElementMenuProps = {
+    autoFocus?: boolean;
     items: BPMNElementDefinition[];
     labels: BPMNLabels;
     onSelect: (item: BPMNElementDefinition) => void;
     selectedId?: BPMNElementId;
 };
 /** Renders the compact catalog list shared by toolbars and transformation menus. */
-export declare function BPMNElementMenu({ items, labels, onSelect, selectedId, }: BPMNElementMenuProps): import("react").JSX.Element;
+export declare function BPMNElementMenu({ autoFocus, items, labels, onSelect, selectedId, }: BPMNElementMenuProps): import("react").JSX.Element;
 export {};

package/dist/src/Diagrams/custom/bpmn/ui/BPMNIcon.d.ts

@@ -1,4 +1,4 @@
-export type BPMNIconId = "task" | "serviceTask" | "sendTask" | "receiveTask" | "scriptTask" | "manualTask" | "businessRuleTask" | "callActivity" | "subprocess" | "eventSubprocess" | "event" | "start" | "intermediate" | "end" | "timer" | "message" | "messageCatch" | "messageThrow" | "signal" | "compensation" | "error" | "conditional" | "terminate" | "exclusive" | "inclusive" | "parallel" | "eventBased" | "lanes" | "blackBoxPool" | "dataStore" | "document" | "documentAnnotation" | "textAnnotation" | "transform" | "connect" | "settings";
+export type BPMNIconId = "task" | "serviceTask" | "sendTask" | "receiveTask" | "scriptTask" | "manualTask" | "businessRuleTask" | "callActivity" | "subprocess" | "eventSubprocess" | "event" | "start" | "intermediate" | "end" | "timer" | "message" | "messageCatch" | "messageThrow" | "signal" | "compensation" | "error" | "conditional" | "cancel" | "escalation" | "link" | "multiple" | "parallelMultiple" | "terminate" | "exclusive" | "inclusive" | "parallel" | "eventBased" | "complex" | "lanes" | "blackBoxPool" | "dataStore" | "document" | "dataInput" | "dataOutput" | "documentAnnotation" | "textAnnotation" | "transform" | "connect" | "settings";
 type BPMNIconProps = {
     id: BPMNIconId;
     className?: string;

package/dist/src/Diagrams/custom/bpmn/ui/BPMNPropertiesPanel.d.ts

@@ -1,6 +1,16 @@
+import { ReactNode } from 'react';
 import { TDiagramExtensionRenderProps } from '../../../store/extensions/DiagramExtension';
 import { BPMNModelerExtension } from '../extensions/BPMNModelerExtension';
+type TBPMNPropertiesPanelProps = TDiagramExtensionRenderProps<BPMNModelerExtension> & {
+    sections?: {
+        generalTitle: string;
+        additionalTitle: string;
+        additionalContent: ReactNode;
+        additionalEditable?: boolean;
+    };
+};
 /** Renders the animated fixed inspector for the single selected BPMN element. */
-export declare const BPMNPropertiesPanel: (({ diagram, extension }: TDiagramExtensionRenderProps<BPMNModelerExtension>) => import("react").JSX.Element) & {
+export declare const BPMNPropertiesPanel: (({ diagram, extension, sections }: TBPMNPropertiesPanelProps) => import("react").JSX.Element) & {
     displayName: string;
 };
+export {};

package/dist/src/Diagrams/custom/bpmnExecution/BPMNExecutionDiagram.d.ts

@@ -0,0 +1,30 @@
+import { Edge } from '../../store/elements/Edge';
+import { Gateway } from '../../store/elements/Gateway';
+import { Node } from '../../store/elements/Node';
+import { BPMDiagram, BPMDiagramSettings } from '../bpmn/BPMDiagram';
+import { BPMNExecutionApplyResult, BPMNExecutionSettings, BPMNExecutionSettingsInput, BPMNExecutionSnapshot } from './types';
+export type BPMNExecutionDiagramSettings = BPMDiagramSettings & {
+    execution?: BPMNExecutionSettingsInput;
+};
+/** Extends the complete BPMN modeler with live, serializable process execution state. */
+export declare class BPMNExecutionDiagram extends BPMDiagram {
+    readonly executionSettings: BPMNExecutionSettings;
+    private restoringSerializedState;
+    constructor(settings?: BPMNExecutionDiagramSettings);
+    /** Restores serialized BPMN semantics without ever enabling interactive edition. */
+    import(serializedDiagram: string): void;
+    /** Replaces readonly content through a controlled loader while edition stays disabled. */
+    replaceReadonlyContent(loader: () => void | Promise<void>): Promise<boolean>;
+    /** Adds catalog-created BPMN nodes after promoting them to execution subclasses in place. */
+    add<T extends Node>(node: T): T;
+    /** Registers externally constructed BPMN edges as their execution-aware subclasses. */
+    connectWithEdge(from: Gateway, to: Gateway, edge: Edge): Edge;
+    /** Updates configurable execution colors without mutating semantic element styling. */
+    configureExecution(settings: BPMNExecutionSettingsInput): void;
+    /** Applies one process-engine snapshot and reports identifiers that could not be matched. */
+    applyExecutionSnapshot(snapshot: BPMNExecutionSnapshot): BPMNExecutionApplyResult;
+    /** Clears all operational snapshots while leaving the modeled BPMN process untouched. */
+    clearExecution(): void;
+    private resolveExecutionEdge;
+    private registerExecutionClasses;
+}

package/dist/src/Diagrams/custom/bpmnExecution/BPMNExecutionEdge.d.ts

@@ -0,0 +1,67 @@
+import { BPMNEdge } from '../bpmn/edges/BPMNEdge';
+import { BPMNEdgeExecutionSnapshot } from './types';
+type BPMNExecutionEdgeState = ConstructorParameters<typeof BPMNEdge>[1] & {
+    executionId?: string;
+    execution?: BPMNEdgeExecutionSnapshot;
+};
+/** Extends a BPMN flow with visit history and configurable execution styling. */
+export declare class BPMNExecutionEdge extends BPMNEdge {
+    executionId: string;
+    visited: boolean;
+    visitCount: number;
+    visitedAt: string | null;
+    constructor(parent: ConstructorParameters<typeof BPMNEdge>[0], state: BPMNExecutionEdgeState);
+    get stroke(): string | undefined;
+    /** Applies one visited-flow snapshot without altering routing or BPMN semantics. */
+    applyExecution(snapshot?: BPMNEdgeExecutionSnapshot): void;
+    /** Clears visit history while preserving the underlying BPMN flow definition. */
+    resetExecution(): void;
+    /** Replaces the stable external identifier used to match execution snapshots. */
+    setExecutionId(executionId: string): void;
+    /** Serializes execution identity and visit history beside normal BPMN edge data. */
+    serialize(): {
+        executionId: string;
+        execution: {
+            visited: boolean;
+            visitCount: number;
+            visitedAt: string | null;
+        };
+        kind: import('../bpmn/edges/BPMNEdge').BPMNEdgeKind;
+        condition: string;
+        isDefault: boolean;
+        isDirected: boolean;
+        arrowHeadEnd: import('../../store/types').EdgeArrowHead | undefined;
+        arrowHeadStart: import('../../store/types').EdgeArrowHead | undefined;
+        displacementEnd: [number, number] | undefined;
+        displacementStart: [number, number] | undefined;
+        lineStyle: import('../../store/types').EdgeLineStyle | undefined;
+        labels: {
+            alignment: "right" | "left" | "center";
+            id: string;
+            size: {
+                height: number;
+                width: number;
+            };
+            text: string;
+            position: [number, number];
+        }[];
+        pathType: import('../../store/types').EdgePathType;
+        startAnchor: {
+            mode: import('../../store/types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
+        endAnchor: {
+            mode: import('../../store/types').EdgeAnchorMode;
+            position: [number, number] | undefined;
+        };
+        steps: import('../../store/elements/EdgePoint').TSerializedEdgePoint[];
+        stroke: string | undefined;
+        strokeWidth: number | undefined;
+        to: string;
+        toParentId: string;
+        class: string;
+    };
+    /** Restores BPMN routing before applying independently persisted execution data. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}
+export {};

package/dist/src/Diagrams/custom/bpmnExecution/BPMNExecutionExtension.d.ts

@@ -0,0 +1,9 @@
+import { DiagramExtension } from '../../store/extensions/DiagramExtension';
+/** Contributes floating execution badges without adding a second inspector panel. */
+export declare class BPMNExecutionExtension extends DiagramExtension {
+    RenderDiagram: (({ diagram, }: import('../../store/extensions/DiagramExtension').TDiagramExtensionRenderProps<BPMNExecutionExtension>) => import("react").JSX.Element) & {
+        displayName: string;
+    };
+    /** Initializes the visual execution layer without changing BPMN modeler behavior. */
+    init(): void;
+}

package/dist/src/Diagrams/custom/bpmnExecution/BPMNExecutionMarker.d.ts

@@ -0,0 +1,12 @@
+import { BPMNExecutionMarkerKind, BPMNExecutionMarkerSnapshot } from './types';
+/** Models one independently extensible badge floating over a BPMN execution node. */
+export declare class BPMNExecutionMarker {
+    readonly id: string;
+    kind: BPMNExecutionMarkerKind;
+    value: number | string | null;
+    message: string;
+    color: string | null;
+    constructor(snapshot: BPMNExecutionMarkerSnapshot);
+    /** Produces the stable persistence representation of this floating marker. */
+    serialize(): BPMNExecutionMarkerSnapshot;
+}

package/dist/src/Diagrams/custom/bpmnExecution/BPMNNodeExecutionState.d.ts

@@ -0,0 +1,27 @@
+import { BPMNExecutionMarker } from './BPMNExecutionMarker';
+import { BPMNExecutionStatus, BPMNNodeExecutionSnapshot } from './types';
+/** Owns runtime-only status and floating markers for one executable BPMN node. */
+export declare class BPMNNodeExecutionState {
+    private currentStatus;
+    private activeTokenCount;
+    private errorMessage;
+    markers: BPMNExecutionMarker[];
+    constructor(snapshot?: BPMNNodeExecutionSnapshot);
+    get status(): BPMNExecutionStatus;
+    set status(status: BPMNExecutionStatus);
+    get tokenCount(): number;
+    get error(): string;
+    /** Changes runtime status and synchronizes its single canonical floating marker. */
+    setStatus(status: BPMNExecutionStatus): void;
+    /** Replaces the token badge while normalizing invalid or negative counts to zero. */
+    setTokenCount(tokenCount: number): void;
+    /** Replaces the exception badge while preserving the supplied diagnostic message. */
+    setError(message: string | null): void;
+    /** Applies a complete node snapshot and rebuilds canonical and custom markers. */
+    apply(snapshot?: BPMNNodeExecutionSnapshot): void;
+    /** Clears every operational value without modifying the underlying BPMN semantics. */
+    reset(): void;
+    /** Serializes runtime status together with canonical and extensible floating badges. */
+    serialize(): BPMNNodeExecutionSnapshot;
+    private synchronizeStatusMarker;
+}

package/dist/src/Diagrams/custom/bpmnExecution/isBPMNExecutionNode.d.ts

@@ -0,0 +1,7 @@
+import { Node } from '../../store/elements/Node';
+import { BPMNNodeExecutionState } from './BPMNNodeExecutionState';
+export type BPMNExecutionNode = Node & {
+    execution: BPMNNodeExecutionState;
+};
+/** Narrows promoted or directly constructed nodes to the execution-node contract. */
+export declare function isBPMNExecutionNode(node: Node): node is BPMNExecutionNode;

package/dist/src/Diagrams/custom/bpmnExecution/nodes/BPMNExecutionBlackBoxPoolNode.d.ts

@@ -0,0 +1,70 @@
+import { BlackBoxPoolNode } from '../../bpmn/nodes/BlackBoxPoolNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN black-box participant with execution metadata support. */
+export declare class BPMNExecutionBlackBoxPoolNode extends BlackBoxPoolNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof BlackBoxPoolNode>[0], state: ConstructorParameters<typeof BlackBoxPoolNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes execution metadata together with the hidden-participant model. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        box: [number, number, number, number];
+        id: string;
+        label: string;
+        movable: boolean | undefined;
+        selectable: boolean | undefined;
+        selected: boolean | undefined;
+        gateways: {
+            coordinates: [number, number];
+            fill: string | undefined;
+            id: string;
+            orientation: import('../../../store/types').TOrientation;
+            radius: number;
+            stroke: string | undefined;
+            strokeWidth: number;
+            outEdges: {
+                arrowHeadEnd: import('../../../store/types').EdgeArrowHead | undefined;
+                arrowHeadStart: import('../../../store/types').EdgeArrowHead | undefined;
+                displacementEnd: [number, number] | undefined;
+                displacementStart: [number, number] | undefined;
+                lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+                stroke: string | undefined;
+                strokeWidth: number | undefined;
+                to: string;
+                toParentId: string;
+                class: string;
+            }[];
+            class: string;
+        }[];
+        fill: string | undefined;
+        labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Restores participant state before applying independently stored execution data. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

package/dist/src/Diagrams/custom/bpmnExecution/nodes/BPMNExecutionDataStoreNode.d.ts

@@ -0,0 +1,70 @@
+import { DataStoreNode } from '../../bpmn/nodes/DataStoreNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN data store with optional execution metadata support. */
+export declare class BPMNExecutionDataStoreNode extends DataStoreNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof DataStoreNode>[0], state: ConstructorParameters<typeof DataStoreNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes optional execution metadata beside normal data-store semantics. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        box: [number, number, number, number];
+        id: string;
+        label: string;
+        movable: boolean | undefined;
+        selectable: boolean | undefined;
+        selected: boolean | undefined;
+        gateways: {
+            coordinates: [number, number];
+            fill: string | undefined;
+            id: string;
+            orientation: import('../../../store/types').TOrientation;
+            radius: number;
+            stroke: string | undefined;
+            strokeWidth: number;
+            outEdges: {
+                arrowHeadEnd: import('../../../store/types').EdgeArrowHead | undefined;
+                arrowHeadStart: import('../../../store/types').EdgeArrowHead | undefined;
+                displacementEnd: [number, number] | undefined;
+                displacementStart: [number, number] | undefined;
+                lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+                stroke: string | undefined;
+                strokeWidth: number | undefined;
+                to: string;
+                toParentId: string;
+                class: string;
+            }[];
+            class: string;
+        }[];
+        fill: string | undefined;
+        labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Restores data-store state before applying independent execution metadata. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

package/dist/src/Diagrams/custom/bpmnExecution/nodes/BPMNExecutionDocumentAnnotationNode.d.ts

@@ -0,0 +1,70 @@
+import { DocumentAnnotationNode } from '../../bpmn/nodes/DocumentAnnotationNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a BPMN document annotation without changing its resizing or text behavior. */
+export declare class BPMNExecutionDocumentAnnotationNode extends DocumentAnnotationNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof DocumentAnnotationNode>[0], state: ConstructorParameters<typeof DocumentAnnotationNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes optional execution metadata beside document-annotation state. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        box: [number, number, number, number];
+        id: string;
+        label: string;
+        movable: boolean | undefined;
+        selectable: boolean | undefined;
+        selected: boolean | undefined;
+        gateways: {
+            coordinates: [number, number];
+            fill: string | undefined;
+            id: string;
+            orientation: import('../../../store/types').TOrientation;
+            radius: number;
+            stroke: string | undefined;
+            strokeWidth: number;
+            outEdges: {
+                arrowHeadEnd: import('../../../store/types').EdgeArrowHead | undefined;
+                arrowHeadStart: import('../../../store/types').EdgeArrowHead | undefined;
+                displacementEnd: [number, number] | undefined;
+                displacementStart: [number, number] | undefined;
+                lineStyle: import('../../../store/types').EdgeLineStyle | undefined;
+                labels: {
+                    alignment: "right" | "left" | "center";
+                    id: string;
+                    size: {
+                        height: number;
+                        width: number;
+                    };
+                    text: string;
+                    position: [number, number];
+                }[];
+                pathType: import('../../../store/types').EdgePathType;
+                startAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                endAnchor: {
+                    mode: import('../../../store/types').EdgeAnchorMode;
+                    position: [number, number] | undefined;
+                };
+                steps: import('../../../store/elements/EdgePoint').TSerializedEdgePoint[];
+                stroke: string | undefined;
+                strokeWidth: number | undefined;
+                to: string;
+                toParentId: string;
+                class: string;
+            }[];
+            class: string;
+        }[];
+        fill: string | undefined;
+        labelFontSize: number | undefined;
+        labelOffset: [number, number] | undefined;
+        stroke: string | undefined;
+        strokewWidth: number | undefined;
+        class: string;
+    };
+    /** Restores annotation state before applying independent execution metadata. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}