fixed broken links

Author: Simon Schweizer

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

@@ -0,0 +1,8 @@
+---
+title: Conditions
+icon: creative
+---
+
+### Conditions
+
+[Conditions](https://docs.camunda.org/manual/7.21/user-guide/process-engine/expression-language/#conditions) allow you to change the behaviour of BPMN processes during execution. There are two ways you are able to add decision logic to Conditions. The [Camunda Modeler](https://camunda.com/download/modeler/) refers to them as `Type`. You can find them in the ``Condition`` tab of certain BPMN elements. The first one is `Script`. This allows you to add arbitrary complexity to your decisions logic and is rarely used for process plugins. The more common Type is `Expression`. Expressions have the following syntax: `${expression}`. An example of a simple expression would be a boolean condition like `var == true`. For this to work during BPMN process execution, the variable you want to use for the boolean condition must be available in the BPMN process variables before [Sequence Flow](sequence-flow.md) reaches the evaluation of the expression. You can learn more advanced features of Expressions [here](https://docs.camunda.org/manual/7.21/user-guide/process-engine/expression-language/).

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

@@ -0,0 +1,16 @@
+---
+title: Gateways
+icon: creative
+---
+
+### Gateways
+
+[Gateways](https://docs.camunda.org/manual/7.21/reference/bpmn20/gateways/) allow you to control the [Sequence Flow](sequence-flow.md). Different types of gateways are useful for different scenarios.
+
+#### Exclusive Gateways
+
+[Exclusive Gateways](https://docs.camunda.org/manual/7.21/reference/bpmn20/gateways/exclusive-gateway/) allow you to decide which [Sequence Flow](sequence-flow.md) should be followed based on [conditions](https://docs.camunda.org/manual/7.21/user-guide/process-engine/expression-language/#conditions). [Conditions](https://docs.camunda.org/manual/7.21/user-guide/process-engine/expression-language/#conditions) are not part of the [Exclusive Gateways](https://docs.camunda.org/manual/7.21/reference/bpmn20/gateways/exclusive-gateway/) themselves. You set them through the sequence flow exiting the [Exclusive Gateway](https://docs.camunda.org/manual/7.21/reference/bpmn20/gateways/exclusive-gateway/).  In the [Camunda Modeler](https://camunda.com/download/modeler/), you can add conditions to [Sequence Flow](sequence-flow.md) by selecting a [Sequence Flow](sequence-flow.md) and opening the `Condition` tab. You can find more information on how to use Conditions [here](conditions.md).
+
+#### Event-based Gateway
+
+The [Event-based Gateway](https://docs.camunda.org/manual/7.21/reference/bpmn20/gateways/event-based-gateway/) allows you model scenarios where you are expecting one out of a number of events to occur. 

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).

docs/src/process-development/api-v2/dsf/bpmn-process-execution.md

@@ -0,0 +1,8 @@
+---
+title: BPMN Process Execution
+icon: creative
+---
+
+### BPMN Process Execution
+
+The BPMN process execution is the in-memory representation of a running BPMN process. BPMN processes have their executions structured as a tree hierarchy. Each BPMN process starts with the [process instance](https://docs.camunda.org/manual/7.21/user-guide/process-engine/process-engine-concepts/#process-instances) as its root level execution. If, for example, this root execution reaches a parallel gateway with two paths, it would spawn two child executions under itself for them to process all tasks along their paths on their own. Executions can access all the BPMN elements from the BPMN model as well as the [BPMN process variables](bpmn-process-variables.md). You have access to this representation in your Java code through the `execution` parameter when overriding certain methods in [Service](service-delegates.md) / [Message](message-delegates.md) Delegates like `execute` or `getAdditionalInputParameters` through the `variables` parameter.

docs/src/process-development/api-v2/dsf/bpmn-process-variables.md

@@ -0,0 +1,10 @@
+---
+title: BPMN Process Variables
+icon: creative
+---
+
+### BPMN Process Variables
+
+BPMN process variables hold additional information which has to be available during BPMN process execution. Variables can be directly related to BPMN elements like the boolean value for [Conditions](../bpmn/conditions.md), but do not have to be. BPMN process variables are stored as key-value pairs with the key being the variable name. They are accessible during the entirety of the execution to all [Service](service-delegates.md) / [Message](message-delegates.md) Delegates.
+
+You can learn how to access to the BPMN process variables [here](../guides/accessing-bpmn-process-variables.md).