bpmn concepts stay the say for api v2

Author: jaboehri

docs/src/process-development/api-v2/bpmn/index.md

@@ -0,0 +1,15 @@
+---
+title: BPMN
+icon: creative
+---
+
+## Introduction
+The DSF uses BPMN 2.0 to model processes. Specifically, the [Camunda 7](https://docs.camunda.org/manual/7.21/) dialect from the [Camunda Modeler](https://camunda.com/de/download/modeler/). Modeling processes for the DSF requires this modeler or any other modeler which is able to produce the correct Camunda dialect.
+
+## Details
+- [Conditions](conditions.md)
+- [Gateways](gateways.md)
+- [Messaging](messaging.md)
+- [Sequence Flow](sequence-flow.md)
+- [Service Tasks](service-tasks.md)
+- [Timer Intermediate Catching Events](timer-intermediate-catching-events.md)

docs/src/process-development/api-v2/bpmn/messaging.md

@@ -0,0 +1,24 @@
+---
+title: Messaging
+icon: creative
+---
+
+
+### Messaging
+
+In order to enable communication with other lanes, pools or even entirely separate processes you need to be able to exchange information. In BPMN, you can use [Message Events](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/message-events/) to model this information exchange. Modeling communication with [Message Events](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/message-events/) in the same diagram uses Message Flow. Message Flow is typically represented by a dashed line arrow between BPMN elements with a black (send) or white (receive) envelope icon. The following BPMN collaboration diagram shows message exchange between two processes.
+
+![BPMN collaboration diagram with two processes using message flow to exchange information between two organizations](/photos/developer-documentation/message_flow.svg)
+
+#### Message Start Event
+
+[Message Start Events](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/message-events/#message-start-event) allow a BPMN process to be started by an incoming message. In the DSF, all BPMN processes are started via messages. Therefore, you will have to include a [Message Start Event](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/message-events/#message-start-event) at the beginning of all of your BPMN models.
+
+#### Message Intermediate Throwing Event
+[Message Intermediate Throwing Events](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/message-events/#message-intermediate-throwing-event) are used to send messages during process execution.
+
+#### Message Intermediate Catching Event
+[Message Intermediate Catching Events](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/message-events/#message-intermediate-catching-event) serve as the counterpart to [Message Intermediate Throwing Events](messaging.md#message-intermediate-throwing-event). Use them whenever you expect to receive a message from another process or organization during execution.
+
+#### Message End Event
+The [Message End Event](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/message-events/#message-end-event) will stop the execution of a BPMN process and finish by sending a message.

docs/src/process-development/api-v2/bpmn/sequence-flow.md

@@ -0,0 +1,7 @@
+---
+title: Sequence Flow
+icon: creative
+---
+
+### Sequence Flow
+BPMN 2.0 calls the continuous arrows connecting the BPMN elements in BPMN models, Sequence Flow. Sequence Flow exits one BPMN element and points at the next BPMN element to be processed.

docs/src/process-development/api-v2/bpmn/service-tasks.md

@@ -0,0 +1,8 @@
+---
+title: Service Tasks
+icon: creative
+---
+
+### Service Tasks
+
+One of the most common types of BPMN Tasks used for modeling DSF processes is the [Service Task](https://docs.camunda.org/manual/7.21/reference/bpmn20/tasks/service-task/). They are different from regular BPMN Tasks in that they offer the ability to link an implementation to the [Service Task](https://docs.camunda.org/manual/7.21/reference/bpmn20/tasks/service-task/) which can be called and executed by a BPMN engine. The BPE (Business Process Engine) server of the DSF leverages this engine to execute your BPMN processes.

docs/src/process-development/api-v2/bpmn/timer-intermediate-catching-events.md

@@ -0,0 +1,8 @@
+---
+title: Timer Intermediate Catching Events
+icon: creative
+---
+
+### Timer Intermediate Catching Events
+
+A [Timer Intermediate Catching Event](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/timer-events/#timer-intermediate-catching-event) allows you to model stopwatch behavior. A timer is started once the BPMN execution arrives at the event. The duration until the timer runs out is specified using the [ISO 8601 Durations](http://en.wikipedia.org/wiki/ISO_8601#Durations) format. Examples can be found [here](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/timer-events/#time-duration). After running out, the BPMN process executes the [Sequence Flow](sequence-flow.md) following the [Timer Intermediate Catching Event](https://docs.camunda.org/manual/7.21/reference/bpmn20/events/timer-events/#timer-intermediate-catching-event).

docs/src/process-development/api-v2/bpmn/user-tasks.md

@@ -0,0 +1,8 @@
+---
+title: User Tasks
+icon: creative
+---
+
+### User Tasks
+
+User Tasks define a process step that requires some kind of human interaction. Usually this is done by providing some kind of form the user can fill out. The Camunda Modeler allows to configure these forms as either a propriatary format called [Camunda Forms](https://docs.camunda.io/docs/guides/utilizing-forms/) or custom forms called `Embedded or External Task Forms`. The DSF uses such `External Task Forms` in the form of [Questionnaire](https://www.hl7.org/fhir/R4/questionnaire.html) and [Questionnaire Response](https://www.hl7.org/fhir/R4/questionnaireresponse.html) resources. This mechanism is further expanded upon in [User Tasks in the DSF](../guides/user-tasks-in-the-dsf.md).