@focus.matters/diagrams 0.1.2 → 0.2.20

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;
+}

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

@@ -0,0 +1,71 @@
+import { DocumentNode } from '../../bpmn/nodes/DocumentNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN data object with optional execution metadata support. */
+export declare class BPMNExecutionDocumentNode extends DocumentNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof DocumentNode>[0], state: ConstructorParameters<typeof DocumentNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes optional execution metadata beside normal data-object semantics. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        type: import('../../bpmn/nodes/DocumentNode').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 data-object state before applying independent execution metadata. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

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

@@ -0,0 +1,81 @@
+import { EventNode } from '../../bpmn/nodes/EventNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN event with independent process execution state. */
+export declare class BPMNExecutionEventNode extends EventNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof EventNode>[0], state: ConstructorParameters<typeof EventNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes execution data alongside every property owned by the BPMN event. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        type: import('../../bpmn/nodes/BPMNEventDefinition').EventTypes;
+        eventDefinition: Readonly<{
+            stage: import('../../bpmn/nodes/BPMNEventDefinition').EventStage;
+            kind: import('../../bpmn/nodes/BPMNEventDefinition').EventKind;
+            direction: import('../../bpmn/nodes/BPMNEventDefinition').EventDirection;
+        }>;
+        attachedToTaskId: string | null;
+        attachmentOffset: import('../../bpmn/nodes/EventNode').EventAttachmentOffset | null;
+        interrupting: boolean;
+        subprocessStart: boolean;
+        subprocessId: string | null;
+        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 event semantics before applying the independent execution snapshot. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

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

@@ -0,0 +1,71 @@
+import { GateNode } from '../../bpmn/nodes/GateNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN gateway with runtime token and synchronization state. */
+export declare class BPMNExecutionGateNode extends GateNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof GateNode>[0], state: ConstructorParameters<typeof GateNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes execution data alongside every property owned by the BPMN gateway. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        type: import('../../bpmn/nodes/GateNode').GateTypes;
+        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 gateway semantics before applying the independent execution snapshot. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

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

@@ -0,0 +1,14 @@
+import { Lanes } from '../../bpmn/nodes/Lanes';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends standard BPMN lanes while retaining the complete pool and lane behavior. */
+export declare class BPMNExecutionLanes extends Lanes {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof Lanes>[0], state: ConstructorParameters<typeof Lanes>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes execution metadata together with the complete lane and pool model. */
+    serialize(): any;
+    /** Restores lane structure before applying independently stored execution metadata. */
+    deserialize(state: any): void;
+}

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

@@ -0,0 +1,76 @@
+import { TaskNode } from '../../bpmn/nodes/TaskNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN activity with independent process execution state. */
+export declare class BPMNExecutionTaskNode extends TaskNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof TaskNode>[0], state: ConstructorParameters<typeof TaskNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes execution data alongside every property owned by the BPMN task. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        type: import('../../bpmn/nodes/TaskNode').TaskTypes;
+        multiInstance: import('../../bpmn/nodes/TaskNode').TaskMultiInstance;
+        loop: boolean;
+        compensation: boolean;
+        adHoc: boolean;
+        transaction: boolean;
+        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 task semantics before applying the independent execution snapshot. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

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

@@ -0,0 +1,70 @@
+import { TextAnnotationNode } from '../../bpmn/nodes/TextAnnotationNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends a standard BPMN text annotation with optional execution metadata support. */
+export declare class BPMNExecutionTextAnnotationNode extends TextAnnotationNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof TextAnnotationNode>[0], state: ConstructorParameters<typeof TextAnnotationNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes optional execution metadata beside normal text 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;
+}

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

@@ -0,0 +1,71 @@
+import { UnknownBPMNNode } from '../../bpmn/nodes/UnknownBPMNNode';
+import { BPMNNodeExecutionState } from '../BPMNNodeExecutionState';
+import { BPMNNodeExecutionSnapshot } from '../types';
+/** Extends unsupported imported BPMN elements so execution snapshots remain lossless. */
+export declare class BPMNExecutionUnknownNode extends UnknownBPMNNode {
+    execution: BPMNNodeExecutionState;
+    constructor(parent: ConstructorParameters<typeof UnknownBPMNNode>[0], state: ConstructorParameters<typeof UnknownBPMNNode>[1] & {
+        execution?: BPMNNodeExecutionSnapshot;
+    });
+    /** Serializes execution metadata while preserving the unsupported source type. */
+    serialize(): {
+        execution: BPMNNodeExecutionSnapshot;
+        sourceType: string;
+        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 unknown BPMN state before applying independent execution metadata. */
+    deserialize(state: ReturnType<this["serialize"]>): void;
+}

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

@@ -0,0 +1,3 @@
+import { Edge } from '../../store/elements/Edge';
+/** Promotes externally constructed BPMN edges while preserving their endpoint references. */
+export declare function promoteBPMNExecutionEdge<T extends Edge>(edge: T): T;

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

@@ -0,0 +1,3 @@
+import { Node } from '../../store/elements/Node';
+/** Promotes catalog-created BPMN nodes in place while preserving all external references. */
+export declare function promoteBPMNExecutionNode<T extends Node>(node: T): T;

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

@@ -0,0 +1,38 @@
+export type BPMNExecutionStatus = "idle" | "active" | "waiting" | "completed" | "failed";
+export type BPMNExecutionMarkerKind = "token" | "error" | "waiting" | "completed" | (string & {});
+export type BPMNExecutionMarkerSnapshot = {
+    id?: string;
+    kind: BPMNExecutionMarkerKind;
+    value?: number | string | null;
+    message?: string;
+    color?: string;
+};
+export type BPMNNodeExecutionSnapshot = {
+    status?: BPMNExecutionStatus;
+    tokenCount?: number;
+    error?: string | null;
+    markers?: BPMNExecutionMarkerSnapshot[];
+};
+export type BPMNEdgeExecutionSnapshot = {
+    visited?: boolean;
+    visitCount?: number;
+    visitedAt?: string | null;
+};
+export type BPMNExecutionSnapshot = {
+    version?: 1;
+    replace?: boolean;
+    nodes?: Record<string, BPMNNodeExecutionSnapshot>;
+    edges?: Record<string, BPMNEdgeExecutionSnapshot>;
+};
+export type BPMNExecutionApplyResult = {
+    appliedNodes: number;
+    appliedEdges: number;
+    unresolvedNodeIds: string[];
+    unresolvedEdgeIds: string[];
+};
+export type BPMNExecutionSettings = {
+    visitedEdgeColor: string;
+    tokenColor: string;
+    errorColor: string;
+};
+export type BPMNExecutionSettingsInput = Partial<BPMNExecutionSettings>;

package/dist/src/Diagrams/custom/bpmnExecution/ui/BPMNExecutionMarkers.d.ts

@@ -0,0 +1,6 @@
+import { TDiagramExtensionRenderProps } from '../../../store/extensions/DiagramExtension';
+import { BPMNExecutionExtension } from '../BPMNExecutionExtension';
+/** Renders token, exception, and future custom badges at each node's top-right edge. */
+export declare const BPMNExecutionMarkers: (({ diagram, }: TDiagramExtensionRenderProps<BPMNExecutionExtension>) => import("react").JSX.Element) & {
+    displayName: string;
+};

package/dist/src/Diagrams/custom/bpmnExecution/ui/BPMNExecutionPropertiesPanel.d.ts

@@ -0,0 +1,6 @@
+import { TDiagramExtensionRenderProps } from '../../../store/extensions/DiagramExtension';
+import { BPMNModelerExtension } from '../../bpmn/extensions/BPMNModelerExtension';
+/** Adds execution fields as a collapsible section in the standard BPMN inspector. */
+export declare const BPMNExecutionPropertiesPanel: (({ diagram, extension, }: TDiagramExtensionRenderProps<BPMNModelerExtension>) => import("react").JSX.Element) & {
+    displayName: string;
+};