@bpmnkit/core 0.0.27 → 0.1.1

package/dist/bpmn/bpmn-builder.js

@@ -127,6 +127,7 @@ function makeFlowElement(id, type, options) {
                 sequenceFlows: [],
                 textAnnotations: [],
                 associations: [],
+                groups: [],
             };
         case "adHocSubProcess":
             return {
@@ -136,6 +137,7 @@ function makeFlowElement(id, type, options) {
                 sequenceFlows: [],
                 textAnnotations: [],
                 associations: [],
+                groups: [],
             };
         case "eventSubProcess":
             return {
@@ -145,6 +147,7 @@ function makeFlowElement(id, type, options) {
                 sequenceFlows: [],
                 textAnnotations: [],
                 associations: [],
+                groups: [],
             };
         case "transaction":
             return {
@@ -154,7 +157,10 @@ function makeFlowElement(id, type, options) {
                 sequenceFlows: [],
                 textAnnotations: [],
                 associations: [],
+                groups: [],
             };
+        default:
+            return { ...base, type };
     }
 }
 function buildMultiInstance(options) {
@@ -333,6 +339,31 @@ function makeInclusiveGatewayEl(id, options) {
     }
     return el;
 }
+/**
+ * `subProcess`/`eventSubProcess`/`adHocSubProcess` all take a required content
+ * callback as their 2nd argument and an optional options object as their 3rd.
+ * That shape isn't demonstrated anywhere in this SDK's docs/examples, and
+ * callers that only see the parameter *names* (not enforced types — e.g.
+ * generated code run without type-checking) sometimes guess the common
+ * "options before callback" order instead. Detect that by runtime type and
+ * swap, so a reversed call still succeeds instead of throwing on `content`
+ * not being callable.
+ */
+function resolveSubProcessArgs(content, options) {
+    if (typeof content === "function") {
+        return {
+            content: content,
+            options: options,
+        };
+    }
+    if (typeof options === "function") {
+        return {
+            content: options,
+            options: content,
+        };
+    }
+    throw new TypeError("subProcess() requires a content callback function");
+}
 // ---------------------------------------------------------------------------
 // Shared graph helpers — used by ProcessBuilder and SubProcessContentBuilder
 // ---------------------------------------------------------------------------
@@ -712,6 +743,120 @@ export class BranchBuilder {
         this.openBranchEnds = savedOpenEnds;
         return this;
     }
+    // ---- Sub-process ----
+    /** Add a sub-process (mirrors `ProcessBuilder.subProcess`). */
+    subProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
+        if (element.type === "subProcess") {
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+            if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
+            }
+        }
+        return this.addElement(element);
+    }
+    /** Add an ad-hoc sub-process (mirrors `ProcessBuilder.adHocSubProcess`). */
+    adHocSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const zeebeExt = {};
+        if (resolved.options?.taskDefinition) {
+            zeebeExt.taskDefinition = resolved.options.taskDefinition;
+        }
+        if (resolved.options?.ioMapping) {
+            zeebeExt.ioMapping = {
+                inputs: resolved.options.ioMapping.inputs ?? [],
+                outputs: resolved.options.ioMapping.outputs ?? [],
+            };
+        }
+        if (resolved.options?.taskHeaders) {
+            zeebeExt.taskHeaders = {
+                headers: Object.entries(resolved.options.taskHeaders).map(([key, value]) => ({
+                    key,
+                    value,
+                })),
+            };
+        }
+        const extensionElements = zeebeExtensionsToXmlElements(zeebeExt);
+        const adHocAttrs = {};
+        if (resolved.options?.activeElementsCollection) {
+            adHocAttrs.activeElementsCollection = resolved.options.activeElementsCollection;
+        }
+        if (resolved.options?.outputCollection) {
+            adHocAttrs.outputCollection = resolved.options.outputCollection;
+        }
+        if (resolved.options?.outputElement) {
+            adHocAttrs.outputElement = resolved.options.outputElement;
+        }
+        if (Object.keys(adHocAttrs).length > 0) {
+            extensionElements.push({
+                name: "zeebe:adHoc",
+                attributes: adHocAttrs,
+                children: [],
+            });
+        }
+        const element = makeFlowElement(id, "adHocSubProcess", {
+            name: resolved.options?.name,
+            extensionElements,
+        });
+        if (resolved.options?.modelerTemplate) {
+            element.unknownAttributes["zeebe:modelerTemplate"] = resolved.options.modelerTemplate;
+        }
+        if (resolved.options?.modelerTemplateVersion) {
+            element.unknownAttributes["zeebe:modelerTemplateVersion"] =
+                resolved.options.modelerTemplateVersion;
+        }
+        if (resolved.options?.modelerTemplateIcon) {
+            element.unknownAttributes["zeebe:modelerTemplateIcon"] = resolved.options.modelerTemplateIcon;
+        }
+        if (element.type === "adHocSubProcess") {
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+            if (resolved.options?.loopCharacteristics) {
+                element.loopCharacteristics = buildAdHocLoopCharacteristics(resolved.options.loopCharacteristics);
+            }
+            else if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
+            }
+        }
+        return this.addElement(element);
+    }
+    /** Add an event sub-process. Triggered by its start event — no incoming or outgoing sequence flows. */
+    eventSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
+        if (element.type === "subProcess") {
+            element.triggeredByEvent = true;
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+        }
+        // Event sub-processes have no incoming/outgoing sequence flows and must not
+        // advance the branch cursor — mirrors ProcessBuilder.eventSubProcess.
+        if (this._elements.some((n) => n.id === element.id)) {
+            throw new Error(`Duplicate element ID "${element.id}"`);
+        }
+        this._elements.push(element);
+        return this;
+    }
     /**
      * Create a named branch from the last gateway added inside this branch.
      *
@@ -976,6 +1121,172 @@ export class SubProcessContentBuilder {
         this.currentGatewayId = undefined;
         return this;
     }
+    // ---- Boundary events ----
+    /**
+     * Add a boundary event attached to an existing activity in this sub-process.
+     *
+     * The boundary event is NOT connected by a sequence flow — it attaches via
+     * `attachedToRef`. The builder cursor advances to the boundary event so
+     * subsequent elements chain from it. Use `withBoundary()` if you want the
+     * cursor to return to the task afterward.
+     */
+    boundaryEvent(id, options) {
+        const element = makeFlowElement(id, "boundaryEvent", options);
+        if (element.type === "boundaryEvent") {
+            element.attachedToRef = options.attachedTo;
+            element.cancelActivity = options.cancelActivity;
+            element.eventDefinitions = buildEventDefinitions(options);
+        }
+        // Push directly — no sequence flow, boundary events attach via attachedToRef
+        this._elements.push(element);
+        this.lastNodeId = element.id;
+        return this;
+    }
+    /**
+     * Attach a boundary event to the preceding task and build its outgoing path,
+     * then restore the builder cursor to the preceding task so the main flow continues.
+     *
+     * @param id - ID for the boundary event element.
+     * @param options - Boundary event options (without `attachedTo` — inferred from cursor).
+     * @param handler - Callback that chains elements from the boundary event.
+     */
+    withBoundary(id, options, handler) {
+        const attachedTo = this.lastNodeId;
+        if (!attachedTo) {
+            throw new Error("withBoundary() must follow a task element inside the sub-process. Current builder position has no active task.");
+        }
+        const attachedEl = this._elements.find((n) => n.id === attachedTo);
+        if (attachedEl?.type === "boundaryEvent") {
+            throw new Error("withBoundary() cannot attach to a boundary event. It must follow a task or activity element.");
+        }
+        const savedLast = this.lastNodeId;
+        const savedGateway = this.currentGatewayId;
+        const savedOpenEnds = [...this.openBranchEnds];
+        this.openBranchEnds = [];
+        // Create and push the boundary event (no sequence flow)
+        this.boundaryEvent(id, { ...options, attachedTo });
+        // Build the boundary event's outgoing path
+        handler(this);
+        // Restore cursor to the task so the sub-process main flow continues
+        this.lastNodeId = savedLast;
+        this.currentGatewayId = savedGateway;
+        this.openBranchEnds = savedOpenEnds;
+        return this;
+    }
+    // ---- Sub-process ----
+    /** Add a sub-process nested inside this sub-process's content. */
+    subProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
+        if (element.type === "subProcess") {
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+            if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
+            }
+        }
+        return this.addElement(element);
+    }
+    /** Add an ad-hoc sub-process nested inside this sub-process's content. */
+    adHocSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const zeebeExt = {};
+        if (resolved.options?.taskDefinition) {
+            zeebeExt.taskDefinition = resolved.options.taskDefinition;
+        }
+        if (resolved.options?.ioMapping) {
+            zeebeExt.ioMapping = {
+                inputs: resolved.options.ioMapping.inputs ?? [],
+                outputs: resolved.options.ioMapping.outputs ?? [],
+            };
+        }
+        if (resolved.options?.taskHeaders) {
+            zeebeExt.taskHeaders = {
+                headers: Object.entries(resolved.options.taskHeaders).map(([key, value]) => ({
+                    key,
+                    value,
+                })),
+            };
+        }
+        const extensionElements = zeebeExtensionsToXmlElements(zeebeExt);
+        const adHocAttrs = {};
+        if (resolved.options?.activeElementsCollection) {
+            adHocAttrs.activeElementsCollection = resolved.options.activeElementsCollection;
+        }
+        if (resolved.options?.outputCollection) {
+            adHocAttrs.outputCollection = resolved.options.outputCollection;
+        }
+        if (resolved.options?.outputElement) {
+            adHocAttrs.outputElement = resolved.options.outputElement;
+        }
+        if (Object.keys(adHocAttrs).length > 0) {
+            extensionElements.push({
+                name: "zeebe:adHoc",
+                attributes: adHocAttrs,
+                children: [],
+            });
+        }
+        const element = makeFlowElement(id, "adHocSubProcess", {
+            name: resolved.options?.name,
+            extensionElements,
+        });
+        if (resolved.options?.modelerTemplate) {
+            element.unknownAttributes["zeebe:modelerTemplate"] = resolved.options.modelerTemplate;
+        }
+        if (resolved.options?.modelerTemplateVersion) {
+            element.unknownAttributes["zeebe:modelerTemplateVersion"] =
+                resolved.options.modelerTemplateVersion;
+        }
+        if (resolved.options?.modelerTemplateIcon) {
+            element.unknownAttributes["zeebe:modelerTemplateIcon"] = resolved.options.modelerTemplateIcon;
+        }
+        if (element.type === "adHocSubProcess") {
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+            if (resolved.options?.loopCharacteristics) {
+                element.loopCharacteristics = buildAdHocLoopCharacteristics(resolved.options.loopCharacteristics);
+            }
+            else if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
+            }
+        }
+        return this.addElement(element);
+    }
+    /** Add an event sub-process. Triggered by its start event — no incoming or outgoing sequence flows. */
+    eventSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
+        const sub = new SubProcessContentBuilder(this.rootMessages);
+        resolved.content(sub);
+        insertJoinGateways(sub._elements, sub._flows);
+        recomputeIncomingOutgoing(sub._elements, sub._flows);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
+        if (element.type === "subProcess") {
+            element.triggeredByEvent = true;
+            element.flowElements = sub._elements;
+            element.sequenceFlows = sub._flows;
+            element.textAnnotations = sub._textAnnotations;
+            element.associations = sub._associations;
+        }
+        // Event sub-processes have no incoming/outgoing sequence flows and must not
+        // advance the cursor — mirrors ProcessBuilder.eventSubProcess.
+        if (this._elements.some((n) => n.id === element.id)) {
+            throw new Error(`Duplicate element ID "${element.id}" in sub-process`);
+        }
+        this._elements.push(element);
+        return this;
+    }
 }
 // ---------------------------------------------------------------------------
 // Process builder (top-level entry point)
@@ -1374,36 +1685,40 @@ export class ProcessBuilder {
     // ---- Sub-processes ----
     /** Add an ad-hoc sub-process with optional AI agent or multi-instance configuration. */
     adHocSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
         const sub = new SubProcessContentBuilder(this.rootMessages);
-        content(sub);
+        resolved.content(sub);
         insertJoinGateways(sub._elements, sub._flows);
         recomputeIncomingOutgoing(sub._elements, sub._flows);
         const zeebeExt = {};
-        if (options?.taskDefinition) {
-            zeebeExt.taskDefinition = options.taskDefinition;
+        if (resolved.options?.taskDefinition) {
+            zeebeExt.taskDefinition = resolved.options.taskDefinition;
         }
-        if (options?.ioMapping) {
+        if (resolved.options?.ioMapping) {
             zeebeExt.ioMapping = {
-                inputs: options.ioMapping.inputs ?? [],
-                outputs: options.ioMapping.outputs ?? [],
+                inputs: resolved.options.ioMapping.inputs ?? [],
+                outputs: resolved.options.ioMapping.outputs ?? [],
             };
         }
-        if (options?.taskHeaders) {
+        if (resolved.options?.taskHeaders) {
             zeebeExt.taskHeaders = {
-                headers: Object.entries(options.taskHeaders).map(([key, value]) => ({ key, value })),
+                headers: Object.entries(resolved.options.taskHeaders).map(([key, value]) => ({
+                    key,
+                    value,
+                })),
             };
         }
         const extensionElements = zeebeExtensionsToXmlElements(zeebeExt);
         // zeebe:adHoc element
         const adHocAttrs = {};
-        if (options?.activeElementsCollection) {
-            adHocAttrs.activeElementsCollection = options.activeElementsCollection;
+        if (resolved.options?.activeElementsCollection) {
+            adHocAttrs.activeElementsCollection = resolved.options.activeElementsCollection;
         }
-        if (options?.outputCollection) {
-            adHocAttrs.outputCollection = options.outputCollection;
+        if (resolved.options?.outputCollection) {
+            adHocAttrs.outputCollection = resolved.options.outputCollection;
         }
-        if (options?.outputElement) {
-            adHocAttrs.outputElement = options.outputElement;
+        if (resolved.options?.outputElement) {
+            adHocAttrs.outputElement = resolved.options.outputElement;
         }
         if (Object.keys(adHocAttrs).length > 0) {
             extensionElements.push({
@@ -1413,28 +1728,29 @@ export class ProcessBuilder {
             });
         }
         const element = makeFlowElement(id, "adHocSubProcess", {
-            name: options?.name,
+            name: resolved.options?.name,
             extensionElements,
         });
-        if (options?.modelerTemplate) {
-            element.unknownAttributes["zeebe:modelerTemplate"] = options.modelerTemplate;
+        if (resolved.options?.modelerTemplate) {
+            element.unknownAttributes["zeebe:modelerTemplate"] = resolved.options.modelerTemplate;
         }
-        if (options?.modelerTemplateVersion) {
-            element.unknownAttributes["zeebe:modelerTemplateVersion"] = options.modelerTemplateVersion;
+        if (resolved.options?.modelerTemplateVersion) {
+            element.unknownAttributes["zeebe:modelerTemplateVersion"] =
+                resolved.options.modelerTemplateVersion;
         }
-        if (options?.modelerTemplateIcon) {
-            element.unknownAttributes["zeebe:modelerTemplateIcon"] = options.modelerTemplateIcon;
+        if (resolved.options?.modelerTemplateIcon) {
+            element.unknownAttributes["zeebe:modelerTemplateIcon"] = resolved.options.modelerTemplateIcon;
         }
         if (element.type === "adHocSubProcess") {
             element.flowElements = sub._elements;
             element.sequenceFlows = sub._flows;
             element.textAnnotations = sub._textAnnotations;
             element.associations = sub._associations;
-            if (options?.loopCharacteristics) {
-                element.loopCharacteristics = buildAdHocLoopCharacteristics(options.loopCharacteristics);
+            if (resolved.options?.loopCharacteristics) {
+                element.loopCharacteristics = buildAdHocLoopCharacteristics(resolved.options.loopCharacteristics);
             }
-            else if (options?.multiInstance) {
-                element.loopCharacteristics = buildMultiInstance(options.multiInstance);
+            else if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
             }
         }
         this.addFlowElement(element);
@@ -1442,18 +1758,19 @@ export class ProcessBuilder {
     }
     /** Add a sub-process (aspirational). */
     subProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
         const sub = new SubProcessContentBuilder(this.rootMessages);
-        content(sub);
+        resolved.content(sub);
         insertJoinGateways(sub._elements, sub._flows);
         recomputeIncomingOutgoing(sub._elements, sub._flows);
-        const element = makeFlowElement(id, "subProcess", options);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
         if (element.type === "subProcess") {
             element.flowElements = sub._elements;
             element.sequenceFlows = sub._flows;
             element.textAnnotations = sub._textAnnotations;
             element.associations = sub._associations;
-            if (options?.multiInstance) {
-                element.loopCharacteristics = buildMultiInstance(options.multiInstance);
+            if (resolved.options?.multiInstance) {
+                element.loopCharacteristics = buildMultiInstance(resolved.options.multiInstance);
             }
         }
         this.addFlowElement(element);
@@ -1461,11 +1778,12 @@ export class ProcessBuilder {
     }
     /** Add an event sub-process. Triggered by its start event — no incoming or outgoing sequence flows. */
     eventSubProcess(id, content, options) {
+        const resolved = resolveSubProcessArgs(content, options);
         const sub = new SubProcessContentBuilder(this.rootMessages);
-        content(sub);
+        resolved.content(sub);
         insertJoinGateways(sub._elements, sub._flows);
         recomputeIncomingOutgoing(sub._elements, sub._flows);
-        const element = makeFlowElement(id, "subProcess", options);
+        const element = makeFlowElement(id, "subProcess", resolved.options);
         if (element.type === "subProcess") {
             element.triggeredByEvent = true;
             element.flowElements = sub._elements;
@@ -1543,6 +1861,7 @@ export class ProcessBuilder {
             sequenceFlows: this.sequenceFlows,
             textAnnotations: this._textAnnotations,
             associations: this._associations,
+            groups: [],
             unknownAttributes: {},
         };
         const defs = {

package/dist/bpmn/bpmn-model.d.ts

@@ -5,7 +5,7 @@ import type { XmlElement } from "../types/xml-element.js";
  * exhaustive `switch` statements and type-narrowing with the type guard helpers
  * exported from `@bpmnkit/core`.
  */
-export type BpmnElementType = "startEvent" | "endEvent" | "intermediateThrowEvent" | "intermediateCatchEvent" | "boundaryEvent" | "task" | "serviceTask" | "scriptTask" | "userTask" | "sendTask" | "receiveTask" | "businessRuleTask" | "manualTask" | "callActivity" | "exclusiveGateway" | "parallelGateway" | "inclusiveGateway" | "eventBasedGateway" | "complexGateway" | "subProcess" | "adHocSubProcess" | "eventSubProcess" | "transaction";
+export type BpmnElementType = "startEvent" | "endEvent" | "intermediateThrowEvent" | "intermediateCatchEvent" | "boundaryEvent" | "task" | "serviceTask" | "scriptTask" | "userTask" | "sendTask" | "receiveTask" | "businessRuleTask" | "manualTask" | "callActivity" | "exclusiveGateway" | "parallelGateway" | "inclusiveGateway" | "eventBasedGateway" | "complexGateway" | "subProcess" | "adHocSubProcess" | "eventSubProcess" | "transaction" | "dataObject" | "dataObjectReference" | "dataStoreReference";
 /** Axis-aligned bounding box used by BPMN diagram interchange (BPMNDi). */
 export interface BpmnBounds {
     x: number;
@@ -150,6 +150,26 @@ export interface BpmnCallActivity extends BpmnFlowNodeBase {
     type: "callActivity";
     loopCharacteristics?: BpmnMultiInstanceLoopCharacteristics;
 }
+/** A data object — a piece of information flowing through the process. */
+export interface BpmnDataObject extends BpmnFlowNodeBase {
+    type: "dataObject";
+    /** When true, represents a collection of items. */
+    isCollection?: boolean;
+}
+/** A visual reference to a {@link BpmnDataObject} (the shape drawn on the canvas). */
+export interface BpmnDataObjectReference extends BpmnFlowNodeBase {
+    type: "dataObjectReference";
+    /** Id of the referenced `dataObject`. */
+    dataObjectRef?: string;
+    /** When true, drawn with the collection (parallel-bars) marker. */
+    isCollection?: boolean;
+}
+/** A visual reference to a data store (drawn as a cylinder). */
+export interface BpmnDataStoreReference extends BpmnFlowNodeBase {
+    type: "dataStoreReference";
+    /** Id of the referenced `dataStore`. */
+    dataStoreRef?: string;
+}
 export interface BpmnSendTask extends BpmnFlowNodeBase {
     type: "sendTask";
     messageRef?: string;
@@ -167,6 +187,7 @@ export interface BpmnAdHocSubProcess extends BpmnFlowNodeBase {
     sequenceFlows: BpmnSequenceFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
 }
 export interface BpmnSubProcess extends BpmnFlowNodeBase {
     type: "subProcess";
@@ -176,6 +197,7 @@ export interface BpmnSubProcess extends BpmnFlowNodeBase {
     sequenceFlows: BpmnSequenceFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
 }
 export interface BpmnEventSubProcess extends BpmnFlowNodeBase {
     type: "eventSubProcess";
@@ -183,6 +205,7 @@ export interface BpmnEventSubProcess extends BpmnFlowNodeBase {
     sequenceFlows: BpmnSequenceFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
 }
 export interface BpmnExclusiveGateway extends BpmnFlowNodeBase {
     type: "exclusiveGateway";
@@ -217,6 +240,7 @@ export interface BpmnTransaction extends BpmnFlowNodeBase {
     sequenceFlows: BpmnSequenceFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
 }
 /**
  * Discriminated union of every BPMN flow node that can appear inside a
@@ -233,7 +257,7 @@ export interface BpmnTransaction extends BpmnFlowNodeBase {
  * }
  * ```
  */
-export type BpmnFlowElement = BpmnStartEvent | BpmnEndEvent | BpmnIntermediateCatchEvent | BpmnIntermediateThrowEvent | BpmnBoundaryEvent | BpmnTask | BpmnServiceTask | BpmnScriptTask | BpmnUserTask | BpmnSendTask | BpmnReceiveTask | BpmnBusinessRuleTask | BpmnManualTask | BpmnCallActivity | BpmnSubProcess | BpmnAdHocSubProcess | BpmnEventSubProcess | BpmnTransaction | BpmnExclusiveGateway | BpmnParallelGateway | BpmnInclusiveGateway | BpmnEventBasedGateway | BpmnComplexGateway;
+export type BpmnFlowElement = BpmnStartEvent | BpmnEndEvent | BpmnIntermediateCatchEvent | BpmnIntermediateThrowEvent | BpmnBoundaryEvent | BpmnTask | BpmnServiceTask | BpmnScriptTask | BpmnUserTask | BpmnSendTask | BpmnReceiveTask | BpmnBusinessRuleTask | BpmnManualTask | BpmnCallActivity | BpmnSubProcess | BpmnAdHocSubProcess | BpmnEventSubProcess | BpmnTransaction | BpmnExclusiveGateway | BpmnParallelGateway | BpmnInclusiveGateway | BpmnEventBasedGateway | BpmnComplexGateway | BpmnDataObject | BpmnDataObjectReference | BpmnDataStoreReference;
 /** Backward-compat alias used by the layout module. */
 export type BpmnFlowNode = BpmnFlowElement;
 /**
@@ -264,6 +288,13 @@ export interface BpmnAssociation {
     associationDirection?: string;
     unknownAttributes: Record<string, string>;
 }
+/** A group artifact — a dashed rounded rectangle visually grouping elements. */
+export interface BpmnGroup {
+    id: string;
+    /** Id of the `categoryValue` supplying the group's label, if any. */
+    categoryValueRef?: string;
+    unknownAttributes: Record<string, string>;
+}
 /** A swim lane within a pool (organises flow nodes visually). */
 export interface BpmnLane {
     id: string;
@@ -294,6 +325,7 @@ export interface BpmnProcess {
     sequenceFlows: BpmnSequenceFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
     laneSet?: BpmnLaneSet;
     unknownAttributes: Record<string, string>;
 }
@@ -319,6 +351,7 @@ export interface BpmnCollaboration {
     messageFlows: BpmnMessageFlow[];
     textAnnotations: BpmnTextAnnotation[];
     associations: BpmnAssociation[];
+    groups: BpmnGroup[];
     extensionElements: XmlElement[];
     unknownAttributes: Record<string, string>;
 }