### BPMN 2.0 Examples Archive

Source: https://www.omg.org/spec/BPMN/2.0/About-BPMN

An archive containing example files for BPMN 2.0, provided as non-normative documentation. These files illustrate various aspects of BPMN usage.

```Archive
https://www.omg.org/cgi-bin/doc?dtc/10-06-02.zip
```

--------------------------------

### BPMN 2.0 Examples Machine Readable Files

Source: https://www.omg.org/spec/BPMN/2.0/About-BPMN

An archive containing machine-readable example files for BPMN 2.0, provided as non-normative documentation. These files are suitable for programmatic processing.

```Archive
https://www.omg.org/cgi-bin/doc?dtc/10-06-03.zip
```

--------------------------------

### BPMN Start Event Template

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

This XSLT template defines a Start Event in BPMN by calling the 'CatchEventTemplate' and checking for the 'isInterrupting' attribute. It signifies the beginning of a process instance.

```xslt
<xsl:template name="StartEventTemplate">
		<xsl:call-template name="CatchEventTemplate" />
		<xsl:if test="@isInterrupting">
		</xsl:if>
	</xsl:template>
```

--------------------------------

### BPMN Specification History

Source: https://www.omg.org/spec/BPMN/1.2/About-BPMN

Provides a historical overview of BPMN specification versions, including adoption dates and URLs for each formal release.

```text
Version | Adoption Date | URL
---|---|---
1.2 | January 2009 | https://www.omg.org/spec/BPMN/1.2
1.1 | January 2008 | https://www.omg.org/spec/BPMN/1.1
1.0 | March 2007 | https://www.omg.org/spec/BPMN/1.0
```

--------------------------------

### BPMN 2.0 Specification Documents

Source: https://www.omg.org/spec/BPMN/2

Lists the available specification documents for BPMN 2.0, categorized into Normative and Informative. Includes links to PDF, machine-readable formats (CMOF, XSD), and supporting files.

```APIDOC
BPMN 2.0 Specification Documents:

Normative Documents:
  - Specification (PDF): https://www.omg.org/spec/BPMN/2.0/PDF (OMG File ID: formal/11-01-03)

Normative Machine Readable Documents:
  - BPMN20.cmof (Eclipse cmof): https://www.omg.org/spec/BPMN/20100501/BPMN20.cmof (OMG File ID: dtc/10-05-04)
  - BPMNDI.cmof (Eclipse cmof): https://www.omg.org/spec/BPMN/20100501/BPMNDI.cmof (OMG File ID: dtc/10-05-04)
  - DC.cmof (Eclipse cmof): https://www.omg.org/spec/BPMN/20100501/DC.cmof (OMG File ID: dtc/10-05-04)
  - DI.cmof (Eclipse cmof): https://www.omg.org/spec/BPMN/20100501/DI.cmof (OMG File ID: dtc/10-05-04)
  - BPMN20.xsd (XML Schema): https://www.omg.org/spec/BPMN/20100501/BPMN20.xsd (OMG File ID: dtc/10-05-04)
  - BPMNDI.xsd (XML Schema): https://www.omg.org/spec/BPMN/20100501/BPMNDI.xsd (OMG File ID: dtc/10-05-04)
  - DC.xsd (XML Schema): https://www.omg.org/spec/BPMN/20100501/DC.xsd (OMG File ID: dtc/10-05-04)
  - DI.xsd (XML Schema): https://www.omg.org/spec/BPMN/20100501/DI.xsd (OMG File ID: dtc/10-05-04)
  - Semantic.xsd (XML Schema): https://www.omg.org/spec/BPMN/20100501/Semantic.xsd (OMG File ID: dtc/10-05-04)
  - BPMN20-FromXMI.xslt (XSLT): https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI.xslt (OMG File ID: dtc/10-05-04)
  - Infrastructure.cmof (Eclipse cmof): https://www.omg.org/spec/BPMN/20100502/Infrastructure.cmof (OMG File ID: dtc/10-05-15)

Informative Documents:
  - BPMN 2.0 examples non-normative document (PDF): https://www.omg.org/cgi-bin/doc?dtc/10-06-02.pdf (OMG File ID: dtc/10-06-02)
  - BPMN 2.0 examples non-normative document (Archive): https://www.omg.org/cgi-bin/doc?dtc/10-06-02.zip (OMG File ID: dtc/10-06-02)
  - BPMN 2.0 examples non-normative machine readable files (Archive): https://www.omg.org/cgi-bin/doc?dtc/10-06-03.zip (OMG File ID: dtc/10-06-03)
  - Specification changebar (PDF): https://www.omg.org/spec/BPMN/2.0/PDF/changebar (OMG File ID: formal/11-01-04)
```

--------------------------------

### BPMN tCatchEvent Definition

Source: https://www.omg.org/spec/BPMN/20100501/Semantic

Abstract definition for a Catch Event in BPMN, such as Start, Intermediate Catch, or End Events that receive messages or signals. It includes data outputs and event definitions.

```APIDOC
tCatchEvent:
  Inherits from: tEvent (abstract)
  Description: Abstract base type for BPMN Catch Events.
  Sequence:
    - dataOutput: dataOutput (0..unbounded) - Data outputs from the event.
    - dataOutputAssociation: dataOutputAssociation (0..unbounded) - Associations for data outputs.
    - outputSet: outputSet (0..1) - Defines the set of outputs.
    - eventDefinition: eventDefinition (0..unbounded) - Specific event definitions (e.g., message, timer).
    - eventDefinitionRef: QName (0..unbounded) - References to external event definitions.
  Attributes:
    - parallelMultiple: boolean (default: false) - Indicates if the event is triggered by multiple parallel events.
```

--------------------------------

### BPMN Specification Links

Source: https://www.omg.org/spec/BPMN/1.2/About-BPMN

Lists various links related to the BPMN specification, including direct document links, RDF/JSON-LD representations, and contact information.

```text
This Document: <https://www.omg.org/spec/BPMN/1.2/About-BPMN>
RDF: <https://www.omg.org/spec/BPMN/1.2/About-BPMN.rdf>
JSON-LD: <https://www.omg.org/spec/BPMN/1.2/About-BPMN.jsonld>
Latest Document: <https://www.omg.org/spec/BPMN>
RDF: <https://www.omg.org/spec/BPMN/About-BPMN.rdf>
JSON-LD: <https://www.omg.org/spec/BPMN/About-BPMN.jsonld>
Members Only: <https://www.omg.org/members/spec/BPMN/1.2>
Supersedes: <https://www.omg.org/spec/BPMN/1.2/Beta1>
Contact: [Send a question ⓘ](https://www.omg.org/spec/contact?i=BPMN/1.2)
```

--------------------------------

### BPMN 2.0 Specification Changebar PDF

Source: https://www.omg.org/spec/BPMN/2.0/About-BPMN

A PDF document highlighting the changes introduced in the BPMN 2.0 specification compared to previous versions. Useful for understanding revisions.

```PDF
https://www.omg.org/spec/BPMN/2.0/PDF/changebar
```

--------------------------------

### MultiInstanceBehavior Enumeration

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Defines the behavior for multi-instance activities, specifying how instances are executed.

```APIDOC
MultiInstanceBehavior:
  __enumeration__:
    name: MultiInstanceBehavior
  __literals__:
    None:
      name: None
      description: Indicates no multi-instance behavior.
```

--------------------------------

### BPMN XMI Namespace Information

Source: https://www.omg.org/spec/BPMN/20100501/DI

Provides namespace information for the BPMN XMI definitions, specifying the namespace prefix and URI.

```APIDOC
cmof:Tag:
  Represents metadata associated with an element.
  Attributes:
    xmi:id: Unique identifier for the tag.
    name: Name of the metadata tag.
      - 'org.omg.xmi.nsPrefix': Specifies the XML namespace prefix.
      - 'org.omg.xmi.nsURI': Specifies the XML namespace URI.
    value: The value of the metadata tag.
      - For 'org.omg.xmi.nsPrefix', value is the prefix string (e.g., 'di').
      - For 'org.omg.xmi.nsURI', value is the URI string (e.g., 'http://www.omg.org/spec/DD/20100524/DI-XMI').
    element: The element this tag is associated with (e.g., '_0' which is a cmof:Package).
```

--------------------------------

### BPMN DataAssociation and IO Binding

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Documents BPMN DataAssociation and InputOutputBinding elements, focusing on their references and associations.

```APIDOC
DataAssociation:
  SuperClass: BaseElement
  Associations:
    - name: sourceRef
      description: Reference to the source element.
      type: DataAssociation
      association: A_sourceRef_dataAssociation
    - name: targetRef
      description: Reference to the target element.
      type: DataAssociation
      association: A_targetRef_dataAssociation

InputOutputBinding:
  Associations:
    - name: operationRef
      description: Reference to the operation.
      type: InputOutputBinding
      association: A_operationRef_ioBinding

DataAssociation Properties:
  sourceRef:
    description: The source element of the data association.
    type: DataAssociation
    association: A_sourceRef_dataAssociation
  targetRef:
    description: The target element of the data association.
    type: DataAssociation
    association: A_targetRef_dataAssociation

InputOutputBinding Properties:
  operationRef:
    description: The operation referenced by the binding.
    type: InputOutputBinding
    upper: *
    lower: 0
    owningAssociation: A_operationRef_ioBinding
    association: A_operationRef_ioBinding
```

--------------------------------

### BPMN Specification Documents

Source: https://www.omg.org/spec/BPMN/1.2/About-BPMN

Lists the official documents associated with the BPMN specification, including their format and URLs. This includes normative and informative documents.

```text
Description | Format | URL | OMG File ID
---|---|---|---
Specification | PDF | BPMN/1.2/PDF | formal/09-01-03
Specification changebar | PDF | BPMN/1.2/PDF/changebar | formal/09-01-04
```

--------------------------------

### BPMN Global Task and Resource Handling

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Processes BPMN GlobalTask elements and their associated resources, specifically identifying and transforming Performer, HumanPerformer, and PotentialOwner elements using dedicated templates.

```XSLT
<xsl:template name="GlobalTaskTemplate">
		<xsl:call-template name="CallableElementTemplate" />

		<xsl:for-each
			select="resources[contains(@xmi:type, 'Performer') or contains(@xsi:type, 'Performer')]">
			<bpmn:performer>
				<xsl:call-template name="PerformerTemplate" />
			</bpmn:performer>
		</xsl:for-each>
		<xsl:for-each
			select="resources[contains(@xmi:type, 'HumanPerformer') or contains(@xsi:type, 'HumanPerformer')]">
			<bpmn:humanPerformer>
				<xsl:call-template name="HumanPerformerTemplate" />
			</bpmn:humanPerformer>
		</xsl:for-each>
		<xsl:for-each
			select="resources[contains(@xmi:type, 'PotentialOwner') or contains(@xsi:type, 'PotentialOwner')]">
			<bpmn:potentialOwner>
				<xsl:call-template name="PotentialOwnerTemplate" />
			</bpmn:potentialOwner>
		</xsl:for-each>

	</xsl:template>
```

--------------------------------

### BPMN DataStore Definition

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Defines a BPMN DataStore element, which represents a repository for data. It includes attributes for name, capacity, and unlimited status.

```APIDOC
BPMN_DataStore:
  Attributes:
    name: String
      - The name of the data store.
    capacity: Integer
      - The capacity of the data store.
    isUnlimited: Boolean (default: true)
      - Indicates if the data store has unlimited capacity.
```

--------------------------------

### BPMN XMI Namespace Tags

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Specifies the XML namespace prefix and URI for the BPMN 2.0 specification. These tags are essential for correctly identifying and processing BPMN documents within an XML context.

```XMI
<cmof:Tag xmi:id="_1" name="org.omg.xmi.nsPrefix" value="bpmn" element="_0"/>
<cmof:Tag xmi:id="_2" name="org.omg.xmi.nsURI" value="http://www.omg.org/spec/BPMN/20100524/MODEL-XMI" element="_0"/>
```

--------------------------------

### BPMN DataStore Definition

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Defines the DataStore element, representing persistent data storage within a business process. It inherits from RootElement and ItemAwareElement.

```APIDOC
DataStore:
  name: DataStore
  superClass: RootElement, ItemAwareElement
```

--------------------------------

### XSLT Template for GlobalUserTask

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Handles BPMN GlobalUserTask elements, inheriting from GlobalTaskTemplate. It manages attributes like 'implementation' and 'renderings'.

```XSLT
<xsl:template name="GlobalUserTaskTemplate">
		<xsl:call-template name="GlobalTaskTemplate" />
		<xsl:if test="@implementation">
			<xsl:attribute name="implementation"> <xsl:value-of select="@implementation" /> </xsl:attribute>
		</xsl:if>

		<xsl:for-each select="renderings">
			<bpmn:rendering>
				<xsl:call-template name="RenderingTemplate" />
			</bpmn:rendering>
		</xsl:for-each>

	</xsl:template>
```

--------------------------------

### BPMN DI Package Imports and Relationships

Source: https://www.omg.org/spec/BPMN/20100501/BPMNDI

Details the package imports and associations defined within the BPMN DI meta-model, showing dependencies on other XMI definitions and relationships between BPMN DI elements.

```APIDOC
BPMNDI Package:
  URI: http://www.omg.org/spec/BPMN/20100524/DI-XMI
  Imports:
    - DI.cmof#_0 (from DI.cmof)
    - DC.cmof#_0 (from DC.cmof)

Associations:
  A_plane_diagram:
    Type: Association
    Source: BPMNDiagram
    Target: BPMNPlane
    Property: plane
    Redefined Property: DI.Diagram-rootElement

  A_labelStyle_diagram:
    Type: Association
    Source: BPMNDiagram
    Target: BPMNLabelStyle
    Property: labelStyle
    Subsetted Property: DI.Diagram-ownedStyle

  A_bpmnElement_plane:
    Type: Association
    Source: BPMNPlane
    Target: BaseElement (from BPMN20.cmof)
    Property: bpmnElement
    Redefined Property: DI.DiagramElement-modelElement

  A_bpmnElement_shape:
    Type: Association
    Source: BPMNShape
    Target: BaseElement (from BPMN20.cmof)
    Property: bpmnElement
    Redefined Property: DI.DiagramElement-modelElement

  A_label_shape:
    Type: Association
    Source: BPMNShape
    Target: BPMNLabel
    Property: label
    Subsetted Property: DI.LabeledShape-ownedLabel

  A_choreographyActivityShape_participantBandShape:
    Type: Association
    Source: BPMNShape (as participantBandShape)
    Target: BPMNShape (as choreographyActivityShape)
    Property: choreographyActivityShape

  A_label_edge:
    Type: Association
    Source: BPMNEdge
    Target: BPMNLabel
    Property: label
    Subsetted Property: DI.LabeledEdge-ownedLabel

  A_bpmnElement_edge:
    Type: Association
    Source: BPMNEdge
    Target: BaseElement (from BPMN20.cmof)
    Property: bpmnElement
    Redefined Property: DI.DiagramElement-modelElement

  A_sourceElement_sourceEdge:
    Type: Association
    Source: BPMNEdge
    Target: DiagramElement
    Property: sourceElement
```

--------------------------------

### BPMN Correlation Subscription Templates

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Provides XSLT templates for BPMN correlation subscriptions and property bindings. These templates manage references to correlation keys and data paths, essential for linking messages to process instances.

```XSLT
<xsl:template name="CorrelationSubscriptionTemplate">
		<xsl:call-template name="BaseElementTemplate" />
		<xsl:if test="@correlationKeyRef">
			<xsl:attribute name="correlationKeyRef"> <xsl:value-of select="@correlationKeyRef" /> </xsl:attribute>
		</xsl:if>

		<xsl:for-each select="correlationPropertyBinding">
			<bpmn:correlationPropertyBinding>
				<xsl:call-template name="CorrelationPropertyBindingTemplate" />
			</bpmn:correlationPropertyBinding>
		</xsl:for-each>

	</xsl:template>

	<xsl:template name="CorrelationPropertyBindingTemplate">
		<xsl:call-template name="BaseElementTemplate" />
		<xsl:if test="@correlationPropertyRef">
			<xsl:attribute name="correlationPropertyRef"> <xsl:value-of
				select="@correlationPropertyRef" /> </xsl:attribute>
		</xsl:if>

		<xsl:for-each select="dataPath">
			<bpmn:dataPath>
				<xsl:call-template name="FormalExpressionTemplate" />
			</bpmn:dataPath>
		</xsl:for-each>

	</xsl:template>
```

--------------------------------

### BPMN Data Store Template XSLT

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

XSLT template for BPMN Data Stores. It calls ItemAwareElementTemplate and RootElementTemplate, and sets 'name' and 'capacity' attributes.

```XSLT
<xsl:template name="DataStoreTemplate">
		<xsl:call-template name="ItemAwareElementTemplate" />
		<xsl:call-template name="RootElementTemplate" />
		<xsl:if test="@name">
			<xsl:attribute name="name"> <xsl:value-of select="@name" /> </xsl:attribute>
		</xsl:if>
		<xsl:if test="@capacity">
			<xsl:attribute name="capacity"> <xsl:value-of select="@capacity" /> </xsl:attribute>
		</xsl:if>
	</xsl:template>
```

--------------------------------

### XSLT Template for InclusiveGateway

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Handles BPMN InclusiveGateway elements, inheriting from GatewayTemplate. It manages the 'default' attribute.

```XSLT
<xsl:template name="InclusiveGatewayTemplate">
		<xsl:call-template name="GatewayTemplate" />
		<xsl:if test="@default">
			<xsl:attribute name="default"> <xsl:value-of select="@default" /> </xsl:attribute>
		</xsl:if>
	</xsl:template>
```

--------------------------------

### XSLT Template for Assignment

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Handles BPMN Assignment elements, processing 'from' and 'to' expressions. It calls the ExpressionTemplate for the content of these expressions.

```XSLT
<xsl:template name="AssignmentTemplate">
		<xsl:call-template name="BaseElementTemplate" />

		<xsl:for-each select="from">
			<bpmn:from>
				<xsl:call-template name="ExpressionTemplate" />
			</bpmn:from>
		</xsl:for-each>


		<xsl:for-each select="to">
			<bpmn:to>
				<xsl:call-template name="ExpressionTemplate" />
			</bpmn:to>
		</xsl:for-each>

	</xsl:template>
```

--------------------------------

### BPMN Element Attribute Handling

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Templates for setting common attributes on BPMN diagram elements, such as documentation, resolution, style, and root element references.

```XSLT
<xsl:template name="DiagramElementTemplate"/>

<xsl:template match="*" mode="attributes">
	<xsl:if test="@documentation">
		<xsl:attribute name="documentation"> <xsl:value-of select="@documentation" /> </xsl:attribute>
	</xsl:if>
	<xsl:if test="@resolution">
		<xsl:attribute name="resolution"> <xsl:value-of select="@resolution" /> </xsl:attribute>
	</xsl:if>

	<xsl:if test="@ownedStyle">
		<xsl:attribute name="ownedStyle"> <xsl:value-of select="@ownedStyle" /> </xsl:attribute>
	</xsl:if>

	<xsl:if test="@rootElement">
		<xsl:attribute name="rootElement"> <xsl:value-of select="@rootElement" /> </xsl:attribute>
	</xsl:if>
</xsl:template>
```

--------------------------------

### BPMN InputOutputBinding Definition

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Defines the InputOutputBinding element, used to link input/output data to operations. It references InputSet, OutputSet, and Operation elements.

```APIDOC
InputOutputBinding:
  name: InputOutputBinding
  attributes:
    inputDataRef:
      name: inputDataRef
      type: InputSet
      association: A_inputDataRef_inputOutputBinding
    outputDataRef:
      name: outputDataRef
      type: OutputSet
      association: A_outputDataRef_inputOutputBinding
    operationRef:
      name: operationRef
      type: Operation
      association: A_operationRef_ioBinding
```

--------------------------------

### BPMN Input/Output Specification Template

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Processes BPMN InputOutputSpecification elements, managing data inputs, data outputs, input sets, and output sets. This template is key for defining the data flow and parameters for process elements.

```XSLT
<xsl:template name="InputOutputSpecificationTemplate">
		<xsl:call-template name="BaseElementTemplate" />

		<xsl:for-each select="dataInputs">
			<bpmn:dataInput>
				<xsl:call-template name="DataInputTemplate" />
			</bpmn:dataInput>
		</xsl:for-each>


		<xsl:for-each select="dataOutputs">
			<bpmn:dataOutput>
				<xsl:call-template name="DataOutputTemplate" />
			</bpmn:dataOutput>
		</xsl:for-each>


		<xsl:for-each select="inputSets">
			<bpmn:inputSet>
				<xsl:call-template name="InputSetTemplate" />
			</bpmn:inputSet>
		</xsl:for-each>


		<xsl:for-each select="outputSets">
			<bpmn:outputSet>
				<xsl:call-template name="OutputSetTemplate" />
			</bpmn:outputSet>
		</xsl:for-each>

	</xsl:template>
```

--------------------------------

### XSLT Template for UserTask

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Processes BPMN UserTask elements. It inherits from TaskTemplate and handles specific attributes like 'implementation' and 'renderings'.

```XSLT
<xsl:template name="UserTaskTemplate">
		<xsl:call-template name="TaskTemplate" />
		<xsl:if test="@implementation">
			<xsl:attribute name="implementation"> <xsl:value-of select="@implementation" /> </xsl:attribute>
		</xsl:if>

		<xsl:for-each select="renderings">
			<bpmn:rendering>
				<xsl:call-template name="RenderingTemplate" />
			</bpmn:rendering>
		</xsl:for-each>

	</xsl:template>
```

--------------------------------

### Global Choreography Task Template

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Provides XSLT for creating a Global Choreography Task in BPMN. It inherits from the base Choreography template and specifically handles the initiating participant reference.

```xslt
<xsl:template name="GlobalChoreographyTaskTemplate">
  <xsl:call-template name="ChoreographyTemplate" />
  <xsl:if test="@initiatingParticipantRef">
    <xsl:attribute name="initiatingParticipantRef"> <xsl:value-of
				select="@initiatingParticipantRef" /> </xsl:attribute>
  </xsl:if>
</xsl:template>
```

--------------------------------

### XSLT Template for EventBasedGateway

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Processes BPMN EventBasedGateway elements, inheriting from GatewayTemplate. It handles 'instantiate' and 'eventGatewayType' attributes.

```XSLT
<xsl:template name="EventBasedGatewayTemplate">
		<xsl:call-template name="GatewayTemplate" />
		<xsl:if test="@instantiate">
			<xsl:attribute name="instantiate"> <xsl:value-of select="@instantiate" /> </xsl:attribute>
		</xsl:if>
		<xsl:if test="@eventGatewayType">
			<xsl:attribute name="eventGatewayType"> <xsl:value-of select="@eventGatewayType" /> </xsl:attribute>
		</xsl:if>
	</xsl:template>
```

--------------------------------

### BPMN 2.0 Specification PDF

Source: https://www.omg.org/spec/BPMN/2.0/About-BPMN

The primary normative document for Business Process Model and Notation version 2.0. It defines the standard's graphical notation, semantics, and metamodel.

```PDF
https://www.omg.org/spec/BPMN/2.0/PDF
```

--------------------------------

### BPMN 2.0 XSLT Transformation

Source: https://www.omg.org/spec/BPMN/2.0/About-BPMN

An XSLT stylesheet designed to transform BPMN 2.0 models from XMI format to other representations. Useful for data processing and conversion.

```XSLT
https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI.xslt
```

--------------------------------

### Sub Process Template

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

XSLT template for creating BPMN Sub-Process elements. It handles flow elements, triggered by events, and associated artifacts like associations, groups, and text annotations.

```xslt
<xsl:template name="SubProcessTemplate">
  <xsl:call-template name="ActivityTemplate" />
  <xsl:call-template name="FlowElementsContainerTemplate" />
  <xsl:if test="@triggeredByEvent">
    <xsl:attribute name="triggeredByEvent"> <xsl:value-of select="@triggeredByEvent" /> </xsl:attribute>
  </xsl:if>

  <xsl:for-each
			select="artifacts[contains(@xmi:type, 'Association') or contains(@xsi:type, 'Association')]">
    <bpmn:association>
      <xsl:call-template name="AssociationTemplate" />
    </bpmn:association>
  </xsl:for-each>
  <xsl:for-each
			select="artifacts[contains(@xmi:type, 'Group') or contains(@xsi:type, 'Group')]">
    <bpmn:group>
      <xsl:call-template name="GroupTemplate" />
    </bpmn:group>
  </xsl:for-each>
  <xsl:for-each
			select="artifacts[contains(@xmi:type, 'TextAnnotation') or contains(@xsi:type, 'TextAnnotation')]">
    <bpmn:textAnnotation>
      <xsl:call-template name="TextAnnotationTemplate" />
    </bpmn:textAnnotation>
  </xsl:for-each>

</xsl:template>
```

--------------------------------

### XSLT Template for HumanPerformer

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Handles BPMN HumanPerformer elements by calling the PerformerTemplate. This suggests a hierarchical structure for performer types.

```XSLT
<xsl:template name="HumanPerformerTemplate">
		<xsl:call-template name="PerformerTemplate" />
	</xsl:template>
```

--------------------------------

### BPMN ItemAwareElement and DataState

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Details the ItemAwareElement and DataState elements in BPMN, including their attributes and relationships.

```APIDOC
DataState:
  SuperClass: BaseElement
  Attributes:
    - name: name
      description: The name of the data state.
      type: String

ItemAwareElement:
  SuperClass: BaseElement
  Attributes:
    - name: itemSubjectRef
      description: Reference to the ItemDefinition.
      type: ItemDefinition
      lower: 0
      association: A_itemSubjectRef_itemAwareElement
    - name: dataState
      description: The data state of the item.
      type: DataState
      lower: 0
      isComposite: true
      association: A_dataState_itemAwareElement

Associations:
  A_dataState_itemAwareElement:
    memberEnd: ItemAwareElement-dataState A_dataState_itemAwareElement-itemAwareElement
    ownedEnd:
      name: itemAwareElement
      type: ItemAwareElement
      owningAssociation: A_dataState_itemAwareElement
      association: A_dataState_itemAwareElement
```

--------------------------------

### BPMN Rendering and Performer Definitions

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Defines the Rendering element used for visual representations and performer types like HumanPerformer and PotentialOwner.

```APIDOC
Class: Rendering
  SuperClass: BaseElement
  Description: Represents a visual rendering or UI definition associated with a task.

Class: HumanPerformer
  SuperClass: Performer
  Description: Represents a performer that is a human.

Class: PotentialOwner
  SuperClass: HumanPerformer
  Description: Represents a potential owner of a task, typically a human.
```

--------------------------------

### XSLT: ArtifactTemplate for BPMN

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

A base XSLT template for BPMN Artifact elements. It inherits from BaseElementTemplate, providing a foundation for specific artifact types like text annotations, groups, and associations.

```XSLT
<xsl:template name="ArtifactTemplate">
		<xsl:call-template name="BaseElementTemplate" />
	</xsl:template>
```

--------------------------------

### BPMN BaseElement Structure

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Defines the core 'BaseElement' class in the BPMN metamodel, which serves as a foundation for other BPMN elements. It includes attributes for identification, documentation, and extensibility.

```APIDOC
Class: BaseElement
  Description: Abstract base class for all BPMN elements.
  Attributes:
    - id: String (Unique identifier for the element)
    - extensionDefinitions: ExtensionDefinition[*] (References to extension definitions associated with this element)
    - extensionValues: ExtensionAttributeValue[*] (Composite attribute for extension attribute values)
    - documentation: Documentation[*] (Composite attribute for documentation elements)
```

--------------------------------

### BPMN OutputSet Element and Type

Source: https://www.omg.org/spec/BPMN/20100501/Semantic

Defines the 'outputSet' element, used to specify output parameters for activities. It extends 'tBaseElement' and references data outputs and input sets.

```APIDOC
element name="outputSet" type="tOutputSet"/

complexType name="tOutputSet"
  complexContent
    extension base="tBaseElement"
      sequence
        element name="dataOutputRefs" type="xsd:IDREF" minOccurs="0" maxOccurs="unbounded"/
        element name="optionalOutputRefs" type="xsd:IDREF" minOccurs="0" maxOccurs="unbounded"/
        element name="whileExecutingOutputRefs" type="xsd:IDREF" minOccurs="0" maxOccurs="unbounded"/
        element name="inputSetRefs" type="xsd:IDREF" minOccurs="0" maxOccurs="unbounded"/
      /sequence
      attribute name="name" type="xsd:string"/
    /extension
  /complexContent
/complexType
```

--------------------------------

### XSLT Template for Rendering

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

A simple XSLT template for BPMN Rendering elements. It calls the BaseElementTemplate, indicating it's a common element with base attributes.

```XSLT
<xsl:template name="RenderingTemplate">
		<xsl:call-template name="BaseElementTemplate" />
	</xsl:template>
```

--------------------------------

### XSLT Template for Gateway

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

A base template for BPMN Gateway elements. It calls FlowNodeTemplate and handles the 'gatewayDirection' attribute.

```XSLT
<xsl:template name="GatewayTemplate">
		<xsl:call-template name="FlowNodeTemplate" />
		<xsl:if test="@gatewayDirection">
			<xsl:attribute name="gatewayDirection"> <xsl:value-of select="@gatewayDirection" /> </xsl:attribute>
		</xsl:if>
	</xsl:template>
```

--------------------------------

### BPMN Association Definitions

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Details various associations between BPMN elements, defining relationships like resources, loop conditions, and I/O specifications.

```APIDOC
Association: A_resources_activity
  __association__:
    name: A_resources_activity
    visibility: private
    memberEnd: [Activity-resources, A_resources_activity-activity]
  __ownedEnd__:
    name: activity
    type: Activity
    lower: 0
    owningAssociation: A_resources_activity
    association: A_resources_activity

Association: A_loopCondition_standardLoopCharacteristics
  __association__:
    name: A_loopCondition_standardLoopCharacteristics
    visibility: private
    memberEnd: [StandardLoopCharacteristics-loopCondition, A_loopCondition_standardLoopCharacteristics-standardLoopCharacteristics]
  __ownedEnd__:
    name: standardLoopCharacteristics
    type: StandardLoopCharacteristics
    lower: 0
    owningAssociation: A_loopCondition_standardLoopCharacteristics
    association: A_loopCondition_standardLoopCharacteristics

Association: A_loopCharacteristics_activity
  __association__:
    name: A_loopCharacteristics_activity
    visibility: private
    memberEnd: [Activity-loopCharacteristics, A_loopCharacteristics_activity-activity]
  __ownedEnd__:
    name: activity
    type: Activity
    lower: 0
    owningAssociation: A_loopCharacteristics_activity
    association: A_loopCharacteristics_activity

Association: A_ioSpecification_activity
  __association__:
    name: A_ioSpecification_activity
    visibility: private
    memberEnd: [Activity-ioSpecification, A_ioSpecification_activity-activity]
  __ownedEnd__:
    name: activity
    type: Activity
    lower: 0
    owningAssociation: A_ioSpecification_activity
    association: A_ioSpecification_activity

Association: A_completionCondition_adHocSubProcess
  __association__:
    name: A_completionCondition_adHocSubProcess
    visibility: private
    memberEnd: [AdHocSubProcess-completionCondition, A_completionCondition_adHocSubProcess-adHocSubProcess]
  __ownedEnd__:
    name: adHocSubProcess
    type: AdHocSubProcess
    lower: 0
    owningAssociation: A_completionCondition_adHocSubProcess
    association: A_completionCondition_adHocSubProcess

Association: A_operationRef_receiveTask
  __association__:
    name: A_operationRef_receiveTask
    visibility: private
    memberEnd: [ReceiveTask-operationRef, A_operationRef_receiveTask-receiveTask]
  __ownedEnd__:
    name: receiveTask
    type: ReceiveTask
    upper: *
    lower: 0
    owningAssociation: A_operationRef_receiveTask
    association: A_operationRef_receiveTask

Association: A_operationRef_sendTask
  __association__:
    name: A_operationRef_sendTask
    visibility: private
    memberEnd: [SendTask-operationRef, A_operationRef_sendTask-sendTask]
  __ownedEnd__:
    name: sendTask
    type: SendTask
    upper: *
    lower: 0
    owningAssociation: A_operationRef_sendTask
    association: A_operationRef_sendTask
```

--------------------------------

### BPMN Task Definitions

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Defines various task types within the BPMN specification, including manual and user tasks, and their common attributes like implementation and renderings.

```APIDOC
Class: GlobalManualTask
  SuperClass: GlobalTask
  Description: Represents a manual task that is global in scope.

Class: ManualTask
  SuperClass: Task
  Description: Represents a manual task within a process.

Class: UserTask
  SuperClass: Task
  Description: Represents a task performed by a human user.
  Attributes:
    - renderings: Type 'Rendering', multiplicity '*', optional. Represents visual renderings for the task.
    - implementation: Type 'String'. Specifies the implementation details for the task.
```

--------------------------------

### XSLT Template for ComplexGateway

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Handles BPMN ComplexGateway elements, inheriting from GatewayTemplate. It manages the 'default' attribute and 'activationCondition' expressions.

```XSLT
<xsl:template name="ComplexGatewayTemplate">
		<xsl:call-template name="GatewayTemplate" />
		<xsl:if test="@default">
			<xsl:attribute name="default"> <xsl:value-of select="@default" /> </xsl:attribute>
		</xsl:if>

		<xsl:for-each select="activationCondition">
			<bpmn:activationCondition>
				<xsl:call-template name="ExpressionTemplate" />
			</bpmn:activationCondition>
		</xsl:for-each>

	</xsl:template>
```

--------------------------------

### ResourceParameterBinding Class

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Defines the binding of a resource parameter to an expression. This class links expressions to specific resource parameters.

```APIDOC
Class: ResourceParameterBinding
  Attributes:
    - name: expression
      type: Expression
      isComposite: true
      association: A_expression_resourceParameterBinding
    - name: parameterRef
      type: ResourceParameter
      association: A_parameterRef_resourceParameterBinding
```

--------------------------------

### BPMN XSLT Transformation

Source: https://www.omg.org/spec/BPMN/machine-readable

Provides an XSLT stylesheet for transforming BPMN models from XMI (XML Metadata Interchange) format to BPMN 2.0 XML. This stylesheet is useful for converting or processing BPMN models stored in XMI, a common interchange format for UML and MOF-based models.

```APIDOC
BPMN XSLT Transformation:
  - BPMN20-FromXMI.xslt: XSLT stylesheet to convert XMI to BPMN 2.0 XML.
    URL: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI.xslt
    Description: BPMN20-FromXMI.xslt
    Appears in: 2.0.2
```

--------------------------------

### BPMN Association Definitions

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20

Documents associations between BPMN elements, such as the link between UserTask and Rendering, GlobalUserTask and Rendering, and gateways and their default flow elements.

```APIDOC
Association: A_renderings_usertask
  Visibility: private
  MemberEnd: UserTask-renderings, A_renderings_usertask-usertask
  Description: Association linking UserTask to its renderings.

Association: A_renderings_globalUserTask
  Visibility: private
  MemberEnd: GlobalUserTask-renderings, A_renderings_globalUserTask-globalUserTask
  Description: Association linking GlobalUserTask to its renderings.

Association: A_activationCondition_complexGateway
  Visibility: private
  MemberEnd: ComplexGateway-activationCondition, A_activationCondition_complexGateway-complexGateway
  Description: Association linking ComplexGateway to its activation condition.

Association: A_default_inclusiveGateway
  Visibility: private
  MemberEnd: InclusiveGateway-default, A_default_inclusiveGateway-inclusiveGateway
  Description: Association linking InclusiveGateway to its default sequence flow.

Association: A_default_exclusiveGateway
  Visibility: private
  MemberEnd: ExclusiveGateway-default, A_default_exclusiveGateway-exclusiveGateway
  Description: Association linking ExclusiveGateway to its default sequence flow.
```

--------------------------------

### BPMN Task and Activity Templates

Source: https://www.omg.org/spec/BPMN/20100501/BPMN20-FromXMI

Contains XSLT templates for various BPMN task types (GlobalManualTask, ManualTask) and general activity elements. These templates define attributes related to compensation, default flows, quantities, and resource assignments.

```XSLT
<xsl:template name="GlobalManualTaskTemplate">
		<xsl:call-template name="GlobalTaskTemplate" />
	</xsl:template>

	<xsl:template name="ManualTaskTemplate">
		<xsl:call-template name="TaskTemplate" />
	</xsl:template>

	<xsl:template name="TaskTemplate">
		<xsl:call-template name="ActivityTemplate" />
		<xsl:call-template name="InteractionNodeTemplate" />
	</xsl:template>

	<xsl:template name="ActivityTemplate">
		<xsl:call-template name="FlowNodeTemplate" />
		<xsl:if test="@isForCompensation">
			<xsl:attribute name="isForCompensation"> <xsl:value-of select="@isForCompensation" /> </xsl:attribute>
		</xsl:if>
		<xsl:if test="@default">
			<xsl:attribute name="default"> <xsl:value-of select="@default" /> </xsl:attribute>
		</xsl:if>
		<xsl:if test="@startQuantity">
			<xsl:attribute name="startQuantity"> <xsl:value-of select="@startQuantity" /> </xsl:attribute>
		</xsl:if>
		<xsl:if test="@completionQuantity">
			<xsl:attribute name="completionQuantity"> <xsl:value-of
				select="@completionQuantity" /> </xsl:attribute>
		</xsl:if>

		<xsl:for-each select="ioSpecification">
			<bpmn:ioSpecification>
				<xsl:call-template name="InputOutputSpecificationTemplate" />
			</bpmn:ioSpecification>
		</xsl:for-each>


		<xsl:if test="@boundaryEventRefs">
			<xsl:attribute name="boundaryEventRefs"> <xsl:value-of select="@boundaryEventRefs" /> </xsl:attribute>
		</xsl:if>

		<xsl:for-each select="properties">
			<bpmn:property>
				<xsl:call-template name="PropertyTemplate" />
			</bpmn:property>
		</xsl:for-each>


		<xsl:for-each select="dataInputAssociations">
			<bpmn:dataInputAssociation>
				<xsl:call-template name="DataInputAssociationTemplate" />
			</bpmn:dataInputAssociation>
		</xsl:for-each>


		<xsl:for-each select="dataOutputAssociations">
			<bpmn:dataOutputAssociation>
				<xsl:call-template name="DataOutputAssociationTemplate" />
			</bpmn:dataOutputAssociation>
		</xsl:for-each>


		<xsl:for-each
			select="resources[contains(@xmi:type, 'Performer') or contains(@xsi:type, 'Performer')]">
			<bpmn:performer>
				<xsl:call-template name="PerformerTemplate" />
			</bpmn:performer>
		</xsl:for-each>
		<xsl:for-each
			select="resources[contains(@xmi:type, 'HumanPerformer') or contains(@xsi:type, 'HumanPerformer')]">
			<bpmn:humanPerformer>
				<xsl:call-template name="HumanPerformerTemplate" />
			</bpmn:humanPerformer>
		</xsl:for-each>
		<xsl:for-each

```